441 lines
8.4 KiB
C
441 lines
8.4 KiB
C
/*
|
|
Copyright (C) 2018-2019 Parallel Realities
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
#include "text.h"
|
|
|
|
static void initFont(char *name, char *filename);
|
|
static void drawWord(char *word, int *x, int *y, int startX);
|
|
static void drawTextLines(int x, int y, int size, int align);
|
|
static void drawTextLine(int x, int y, int size, int align, const char *line);
|
|
void calcTextDimensions(const char *text, int size, int *w, int *h);
|
|
void useFont(char *name);
|
|
static void initChars(Font *f);
|
|
static char *nextCharacter(const char *str, int *i);
|
|
static Glyph *findGlyph(char *c);
|
|
|
|
static char drawTextBuffer[1024];
|
|
static Font fontHead;
|
|
static Font *fontTail;
|
|
static Font *activeFont = NULL;
|
|
static float scale;
|
|
|
|
void initFonts(void)
|
|
{
|
|
memset(&fontHead, 0, sizeof(Font));
|
|
fontTail = &fontHead;
|
|
|
|
initFont("roboto", getFileLocation("gfx/fonts/Roboto-Medium.ttf"));
|
|
|
|
useFont("roboto");
|
|
}
|
|
|
|
static void initFont(char *name, char *filename)
|
|
{
|
|
SDL_Texture *texture;
|
|
TTF_Font *font;
|
|
Font *f;
|
|
SDL_Surface *surface, *text;
|
|
SDL_Rect dest;
|
|
Glyph *g;
|
|
int i;
|
|
SDL_Color white = {255, 255, 255, 255};
|
|
|
|
f = malloc(sizeof(Font));
|
|
memset(f, 0, sizeof(Font));
|
|
|
|
font = TTF_OpenFont(filename, FONT_SIZE);
|
|
|
|
initChars(f);
|
|
|
|
surface = SDL_CreateRGBSurface(0, FONT_TEXTURE_SIZE, FONT_TEXTURE_SIZE, 32, 0, 0, 0, 0xff);
|
|
|
|
SDL_SetColorKey(surface, SDL_TRUE, SDL_MapRGBA(surface->format, 0, 0, 0, 0));
|
|
|
|
dest.x = dest.y = 0;
|
|
|
|
for (i = 0 ; i < NUM_GLYPH_BUCKETS ; i++)
|
|
{
|
|
for (g = f->glyphHead[i].next ; g != NULL ; g = g->next)
|
|
{
|
|
text = TTF_RenderUTF8_Blended(font, g->character, white);
|
|
|
|
TTF_SizeText(font, g->character, &dest.w, &dest.h);
|
|
|
|
if (dest.x + dest.w >= FONT_TEXTURE_SIZE)
|
|
{
|
|
dest.x = 0;
|
|
|
|
dest.y += dest.h + 1;
|
|
|
|
if (dest.y + dest.h >= FONT_TEXTURE_SIZE)
|
|
{
|
|
SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_CRITICAL, "Out of glyph space in %dx%d font atlas texture map.", FONT_TEXTURE_SIZE, FONT_TEXTURE_SIZE);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
SDL_BlitSurface(text, NULL, surface, &dest);
|
|
|
|
g->rect = dest;
|
|
|
|
SDL_FreeSurface(text);
|
|
|
|
dest.x += dest.w;
|
|
}
|
|
}
|
|
|
|
TTF_CloseFont(font);
|
|
|
|
texture = toTexture(surface, 1);
|
|
|
|
f->texture = texture;
|
|
|
|
strcpy(f->name, name);
|
|
|
|
fontTail->next = f;
|
|
fontTail = f;
|
|
}
|
|
|
|
static void initChars(Font *f)
|
|
{
|
|
char *characters, *character;
|
|
Glyph *g, *glyphTail;
|
|
int i, bucket;
|
|
|
|
characters = readFile("data/locale/characters.dat");
|
|
|
|
i = 0;
|
|
|
|
character = nextCharacter(characters, &i);
|
|
|
|
while (character)
|
|
{
|
|
bucket = hashcode(character) % NUM_GLYPH_BUCKETS;
|
|
|
|
glyphTail = &f->glyphHead[bucket];
|
|
|
|
/* horrible bit to look for the tail */
|
|
while (glyphTail->next)
|
|
{
|
|
glyphTail = glyphTail->next;
|
|
}
|
|
|
|
g = malloc(sizeof(Glyph));
|
|
memset(g, 0, sizeof(Glyph));
|
|
glyphTail->next = g;
|
|
glyphTail = g;
|
|
|
|
STRNCPY(g->character, character, MAX_NAME_LENGTH);
|
|
|
|
character = nextCharacter(characters, &i);
|
|
}
|
|
|
|
free(characters);
|
|
}
|
|
|
|
void drawText(int x, int y, int size, int align, SDL_Color color, const char *format, ...)
|
|
{
|
|
va_list args;
|
|
|
|
if (activeFont)
|
|
{
|
|
memset(&drawTextBuffer, '\0', sizeof(drawTextBuffer));
|
|
|
|
va_start(args, format);
|
|
vsprintf(drawTextBuffer, format, args);
|
|
va_end(args);
|
|
|
|
if (app.textWidth == 0)
|
|
{
|
|
#if !defined(__amigaos4__) && !defined(__morphos__)
|
|
SDL_SetTextureColorMod(activeFont->texture, 0, 0, 0);
|
|
SDL_SetTextureAlphaMod(activeFont->texture, 255);
|
|
|
|
drawTextLine(x + 2, y + 2, size, align, drawTextBuffer);
|
|
drawTextLine(x + 1, y + 1, size, align, drawTextBuffer);
|
|
|
|
SDL_SetTextureColorMod(activeFont->texture, color.r, color.g, color.b);
|
|
SDL_SetTextureAlphaMod(activeFont->texture, color.a);
|
|
#endif
|
|
|
|
drawTextLine(x, y, size, align, drawTextBuffer);
|
|
}
|
|
else
|
|
{
|
|
#if !defined(__amigaos4__) && !defined(__morphos__)
|
|
SDL_SetTextureColorMod(activeFont->texture, 0, 0, 0);
|
|
SDL_SetTextureAlphaMod(activeFont->texture, 255);
|
|
|
|
drawTextLines(x + 2, y + 2, size, align);
|
|
drawTextLines(x + 1, y + 1, size, align);
|
|
|
|
SDL_SetTextureColorMod(activeFont->texture, color.r, color.g, color.b);
|
|
SDL_SetTextureAlphaMod(activeFont->texture, color.a);
|
|
#endif
|
|
|
|
drawTextLines(x, y, size, align);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void drawTextLines(int x, int y, int size, int align)
|
|
{
|
|
char line[MAX_LINE_LENGTH], token[MAX_WORD_LENGTH];
|
|
int i, n, w, h, currentWidth, len;
|
|
|
|
memset(&line, '\0', sizeof(line));
|
|
memset(&token, '\0', sizeof(token));
|
|
|
|
len = strlen(drawTextBuffer);
|
|
|
|
n = currentWidth = 0;
|
|
|
|
for (i = 0 ; i < len ; i++)
|
|
{
|
|
token[n++] = drawTextBuffer[i];
|
|
|
|
if (drawTextBuffer[i] == ' ' || i == len - 1)
|
|
{
|
|
calcTextDimensions(token, size, &w, &h);
|
|
|
|
if (currentWidth + w > app.textWidth)
|
|
{
|
|
drawTextLine(x, y, size, align, line);
|
|
|
|
currentWidth = 0;
|
|
|
|
y += h;
|
|
|
|
memset(&line, '\0', sizeof(line));
|
|
}
|
|
|
|
strcat(line, token);
|
|
|
|
n = 0;
|
|
|
|
memset(&token, '\0', sizeof(token));
|
|
|
|
currentWidth += w;
|
|
}
|
|
}
|
|
|
|
drawTextLine(x, y, size, align, line);
|
|
}
|
|
|
|
static void drawTextLine(int x, int y, int size, int align, const char *line)
|
|
{
|
|
int i, startX, n, w, h;
|
|
char word[MAX_WORD_LENGTH];
|
|
|
|
scale = size / (FONT_SIZE * 1.0f);
|
|
|
|
startX = x;
|
|
|
|
memset(word, 0, MAX_WORD_LENGTH);
|
|
|
|
n = 0;
|
|
|
|
calcTextDimensions(line, size, &w, &h);
|
|
|
|
if (align == TA_RIGHT)
|
|
{
|
|
x -= w;
|
|
}
|
|
else if (align == TA_CENTER)
|
|
{
|
|
x -= (w / 2);
|
|
}
|
|
|
|
for (i = 0 ; i < strlen(line) ; i++)
|
|
{
|
|
word[n++] = line[i];
|
|
|
|
if (line[i] == ' ')
|
|
{
|
|
drawWord(word, &x, &y, startX);
|
|
|
|
memset(word, 0, MAX_WORD_LENGTH);
|
|
|
|
n = 0;
|
|
}
|
|
}
|
|
|
|
drawWord(word, &x, &y, startX);
|
|
}
|
|
|
|
static void drawWord(char *word, int *x, int *y, int startX)
|
|
{
|
|
int i;
|
|
char *character;
|
|
SDL_Rect dest;
|
|
Glyph *g;
|
|
|
|
i = 0;
|
|
|
|
character = nextCharacter(word, &i);
|
|
|
|
while (character)
|
|
{
|
|
g = findGlyph(character);
|
|
|
|
dest.x = *x;
|
|
dest.y = *y;
|
|
dest.w = g->rect.w * scale;
|
|
dest.h = g->rect.h * scale;
|
|
|
|
SDL_RenderCopy(app.renderer, activeFont->texture, &g->rect, &dest);
|
|
|
|
*x += g->rect.w * scale;
|
|
|
|
character = nextCharacter(word, &i);
|
|
}
|
|
}
|
|
|
|
static Glyph *findGlyph(char *c)
|
|
{
|
|
Glyph *g;
|
|
int bucket;
|
|
|
|
bucket = hashcode(c) % NUM_GLYPH_BUCKETS;
|
|
|
|
for (g = activeFont->glyphHead[bucket].next ; g != NULL ; g = g->next)
|
|
{
|
|
if (strcmp(g->character, c) == 0)
|
|
{
|
|
return g;
|
|
}
|
|
}
|
|
|
|
SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_CRITICAL, "Couldn't find glyph for '%s'", c);
|
|
exit(1);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void useFont(char *name)
|
|
{
|
|
Font *f;
|
|
|
|
for (f = fontHead.next ; f != NULL ; f = f->next)
|
|
{
|
|
if (strcmp(f->name, name) == 0)
|
|
{
|
|
activeFont = f;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void calcTextDimensions(const char *text, int size, int *w, int *h)
|
|
{
|
|
float scale;
|
|
int i;
|
|
char *character;
|
|
Glyph *g;
|
|
|
|
scale = size / (FONT_SIZE * 1.0f);
|
|
|
|
*w = 0;
|
|
*h = 0;
|
|
|
|
i = 0;
|
|
|
|
character = nextCharacter(text, &i);
|
|
|
|
while (character)
|
|
{
|
|
g = findGlyph(character);
|
|
|
|
*w += g->rect.w * scale;
|
|
*h = MAX(g->rect.h * scale, *h);
|
|
|
|
character = nextCharacter(text, &i);
|
|
}
|
|
}
|
|
|
|
int getWrappedTextHeight(char *text, int size)
|
|
{
|
|
char word[MAX_WORD_LENGTH];
|
|
int i, y, n, w, h, currentWidth, len;
|
|
|
|
STRNCPY(drawTextBuffer, text, MAX_LINE_LENGTH);
|
|
|
|
n = 0;
|
|
y = 0;
|
|
h = 0;
|
|
currentWidth = 0;
|
|
len = strlen(drawTextBuffer);
|
|
memset(word, 0, MAX_WORD_LENGTH);
|
|
|
|
for (i = 0 ; i < len ; i++)
|
|
{
|
|
word[n++] = drawTextBuffer[i];
|
|
|
|
if (drawTextBuffer[i] == ' ' || i == len - 1)
|
|
{
|
|
calcTextDimensions(word, size, &w, &h);
|
|
|
|
if (currentWidth + w > app.textWidth)
|
|
{
|
|
currentWidth = 0;
|
|
y += h;
|
|
}
|
|
|
|
currentWidth += w;
|
|
|
|
memset(word, 0, MAX_WORD_LENGTH);
|
|
|
|
n = 0;
|
|
}
|
|
}
|
|
|
|
return y + h;
|
|
}
|
|
|
|
static char *nextCharacter(const char *str, int *i)
|
|
{
|
|
static char character[MAX_NAME_LENGTH];
|
|
|
|
unsigned char bit;
|
|
int n;
|
|
|
|
memset(character, '\0', MAX_NAME_LENGTH);
|
|
|
|
n = 0;
|
|
|
|
while (1)
|
|
{
|
|
bit = (unsigned char)str[*i];
|
|
|
|
if ((bit >= ' ' && bit <= '~') || bit >= 0xC0 || bit == '\0')
|
|
{
|
|
if (n > 0)
|
|
{
|
|
return character[0] != '\0' ? character : NULL;
|
|
}
|
|
}
|
|
|
|
character[n++] = str[*i];
|
|
|
|
*i = *i + 1;
|
|
}
|
|
}
|
|
|