#include "raylib.h" // Declares module functions

#include "config.h" // Defines module configuration flags

#if SUPPORT_MODULE_RTEXT

#include "rlgl.h" // OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2 -> Only DrawTextPro()

#include <stdlib.h> // Required for: malloc(), free()

#include <stdio.h> // Required for: vsprintf()

#include <string.h> // Required for: strcmp(), strstr(), strncpy() [Used in TextReplace()], sscanf() [Used in LoadBMFont()]

#include <stdarg.h> // Required for: va_list, va_start(), vsprintf(), va_end() [Used in TextFormat()]

#include <ctype.h> // Required for: toupper(), tolower() [Used in TextToUpper(), TextToLower()]

#if SUPPORT_FILEFORMAT_TTF || SUPPORT_FILEFORMAT_BDF

#if defined(__GNUC__) // GCC and Clang

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wunused-function"

#endif

#define STB_RECT_PACK_IMPLEMENTATION

#include "external/stb_rect_pack.h" // Required for: ttf/bdf font rectangles packaging

#include <math.h> // Required for: ttf/bdf font rectangles packaging

#if defined(__GNUC__) // GCC and Clang

#pragma GCC diagnostic pop

#endif

#if SUPPORT_FILEFORMAT_TTF

#if defined(__GNUC__) // GCC and Clang

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wunused-function"

#endif

#define STBTT_malloc(x,u) ((void)(u),RL_MALLOC(x))

#define STBTT_free(x,u) ((void)(u),RL_FREE(x))

#define STBTT_STATIC

#define STB_TRUETYPE_IMPLEMENTATION

#include "external/stb_truetype.h" // Required for: ttf font data reading

#if defined(__GNUC__) // GCC and Clang

#pragma GCC diagnostic pop

#endif

#ifndef MAX_TEXT_BUFFER_LENGTH

#define MAX_TEXT_BUFFER_LENGTH 1024 // Size of internal static buffers used on some functions:

// TextFormat(), TextSubtext(), TextToUpper(), TextToLower(), TextToPascal(), TextSplit()

#ifndef MAX_TEXTSPLIT_COUNT

#define MAX_TEXTSPLIT_COUNT 128 // Maximum number of substrings to split: TextSplit()

#ifndef FONT_ATLAS_CORNER_REC_SIZE

// On font atlas image generation [GenImageFontAtlas()], add a 3x3 pixels white rectangle

// at the bottom-right corner of the atlas. It can be useful for shapes drawing, to allow

// drawing text and shapes with a single draw call [SetShapesTexture()]

#define FONT_ATLAS_CORNER_REC_SIZE 3 // Size of white rectangle drawn on font atlas on font loading

static Font defaultFont = { 0 };

static int textLineSpacing = 2;

#if SUPPORT_FILEFORMAT_FNT

static Font LoadBMFont(const char *fileName); // Load a BMFont file (AngelCode font file)

#if SUPPORT_FILEFORMAT_BDF

static GlyphInfo *LoadFontDataBDF(const unsigned char *fileData, int dataSize, const int *codepoints, int codepointCount, int *outFontSize);

extern void LoadFontDefault(void);

extern void UnloadFontDefault(void);

extern void LoadFontDefault(void)

{

#define BIT_CHECK(a,b) ((a) & (1u << (b)))

// Check to see if the font for an image has alreeady been allocated,

// and if no need to upload, then return

if (defaultFont.glyphs != NULL) return;

// NOTE: Using UTF-8 encoding table for Unicode U+0000..U+00FF Basic Latin + Latin-1 Supplement

// REF: http://www.utf8-chartable.de/unicode-utf8-table.pl

defaultFont.glyphCount = 224; // Number of glyphs included in our default font

defaultFont.glyphPadding = 0; // Characters padding

// Default font is directly defined here (data generated from a sprite font image)

// This way, reconstructing Font without creating large global variables

// This data is automatically allocated to Stack and automatically deallocated at the end of this function

unsigned int defaultFontData[512] = {

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00200020, 0x0001b000, 0x00000000, 0x00000000, 0x8ef92520, 0x00020a00, 0x7dbe8000, 0x1f7df45f,

0x4a2bf2a0, 0x0852091e, 0x41224000, 0x10041450, 0x2e292020, 0x08220812, 0x41222000, 0x10041450, 0x10f92020, 0x3efa084c, 0x7d22103c, 0x107df7de,

0xe8a12020, 0x08220832, 0x05220800, 0x10450410, 0xa4a3f000, 0x08520832, 0x05220400, 0x10450410, 0xe2f92020, 0x0002085e, 0x7d3e0281, 0x107df41f,

0x00200000, 0x8001b000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xc0000fbe, 0xfbf7e00f, 0x5fbf7e7d, 0x0050bee8, 0x440808a2, 0x0a142fe8, 0x50810285, 0x0050a048,

0x49e428a2, 0x0a142828, 0x40810284, 0x0048a048, 0x10020fbe, 0x09f7ebaf, 0xd89f3e84, 0x0047a04f, 0x09e48822, 0x0a142aa1, 0x50810284, 0x0048a048,

0x04082822, 0x0a142fa0, 0x50810285, 0x0050a248, 0x00008fbe, 0xfbf42021, 0x5f817e7d, 0x07d09ce8, 0x00008000, 0x00000fe0, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x000c0180,

0xdfbf4282, 0x0bfbf7ef, 0x42850505, 0x004804bf, 0x50a142c6, 0x08401428, 0x42852505, 0x00a808a0, 0x50a146aa, 0x08401428, 0x42852505, 0x00081090,

0x5fa14a92, 0x0843f7e8, 0x7e792505, 0x00082088, 0x40a15282, 0x08420128, 0x40852489, 0x00084084, 0x40a16282, 0x0842022a, 0x40852451, 0x00088082,

0xc0bf4282, 0xf843f42f, 0x7e85fc21, 0x3e0900bf, 0x00000000, 0x00000004, 0x00000000, 0x000c0180, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x04000402, 0x41482000, 0x00000000, 0x00000800,

0x04000404, 0x4100203c, 0x00000000, 0x00000800, 0xf7df7df0, 0x514bef85, 0xbefbefbe, 0x04513bef, 0x14414500, 0x494a2885, 0xa28a28aa, 0x04510820,

0xf44145f0, 0x474a289d, 0xa28a28aa, 0x04510be0, 0x14414510, 0x494a2884, 0xa28a28aa, 0x02910a00, 0xf7df7df0, 0xd14a2f85, 0xbefbe8aa, 0x011f7be0,

0x00000000, 0x00400804, 0x20080000, 0x00000000, 0x00000000, 0x00600f84, 0x20080000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0xac000000, 0x00000f01, 0x00000000, 0x00000000, 0x24000000, 0x00000f01, 0x00000000, 0x06000000, 0x24000000, 0x00000f01, 0x00000000, 0x09108000,

0x24fa28a2, 0x00000f01, 0x00000000, 0x013e0000, 0x2242252a, 0x00000f52, 0x00000000, 0x038a8000, 0x2422222a, 0x00000f29, 0x00000000, 0x010a8000,

0x2412252a, 0x00000f01, 0x00000000, 0x010a8000, 0x24fbe8be, 0x00000f01, 0x00000000, 0x0ebe8000, 0xac020000, 0x00000f01, 0x00000000, 0x00048000,

0x0003e000, 0x00000f00, 0x00000000, 0x00008000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000038, 0x8443b80e, 0x00203a03,

0x02bea080, 0xf0000020, 0xc452208a, 0x04202b02, 0xf8029122, 0x07f0003b, 0xe44b388e, 0x02203a02, 0x081e8a1c, 0x0411e92a, 0xf4420be0, 0x01248202,

0xe8140414, 0x05d104ba, 0xe7c3b880, 0x00893a0a, 0x283c0e1c, 0x04500902, 0xc4400080, 0x00448002, 0xe8208422, 0x04500002, 0x80400000, 0x05200002,

0x083e8e00, 0x04100002, 0x804003e0, 0x07000042, 0xf8008400, 0x07f00003, 0x80400000, 0x04000022, 0x00000000, 0x00000000, 0x80400000, 0x04000002,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00800702, 0x1848a0c2, 0x84010000, 0x02920921, 0x01042642, 0x00005121, 0x42023f7f, 0x00291002,

0xefc01422, 0x7efdfbf7, 0xefdfa109, 0x03bbbbf7, 0x28440f12, 0x42850a14, 0x20408109, 0x01111010, 0x28440408, 0x42850a14, 0x2040817f, 0x01111010,

0xefc78204, 0x7efdfbf7, 0xe7cf8109, 0x011111f3, 0x2850a932, 0x42850a14, 0x2040a109, 0x01111010, 0x2850b840, 0x42850a14, 0xefdfbf79, 0x03bbbbf7,

0x001fa020, 0x00000000, 0x00001000, 0x00000000, 0x00002070, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x08022800, 0x00012283, 0x02430802, 0x01010001, 0x8404147c, 0x20000144, 0x80048404, 0x00823f08, 0xdfbf4284, 0x7e03f7ef, 0x142850a1, 0x0000210a,

0x50a14684, 0x528a1428, 0x142850a1, 0x03efa17a, 0x50a14a9e, 0x52521428, 0x142850a1, 0x02081f4a, 0x50a15284, 0x4a221428, 0xf42850a1, 0x03efa14b,

0x50a16284, 0x4a521428, 0x042850a1, 0x0228a17a, 0xdfbf427c, 0x7e8bf7ef, 0xf7efdfbf, 0x03efbd0b, 0x00000000, 0x04000000, 0x00000000, 0x00000008,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00200508, 0x00840400, 0x11458122, 0x00014210,

0x00514294, 0x51420800, 0x20a22a94, 0x0050a508, 0x00200000, 0x00000000, 0x00050000, 0x08000000, 0xfefbefbe, 0xfbefbefb, 0xfbeb9114, 0x00fbefbe,

0x20820820, 0x8a28a20a, 0x8a289114, 0x3e8a28a2, 0xfefbefbe, 0xfbefbe0b, 0x8a289114, 0x008a28a2, 0x228a28a2, 0x08208208, 0x8a289114, 0x088a28a2,

0xfefbefbe, 0xfbefbefb, 0xfa2f9114, 0x00fbefbe, 0x00000000, 0x00000040, 0x00000000, 0x00000000, 0x00000000, 0x00000020, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00210100, 0x00000004, 0x00000000, 0x00000000, 0x14508200, 0x00001402, 0x00000000, 0x00000000,

0x00000010, 0x00000020, 0x00000000, 0x00000000, 0xa28a28be, 0x00002228, 0x00000000, 0x00000000, 0xa28a28aa, 0x000022e8, 0x00000000, 0x00000000,

0xa28a28aa, 0x000022a8, 0x00000000, 0x00000000, 0xa28a28aa, 0x000022e8, 0x00000000, 0x00000000, 0xbefbefbe, 0x00003e2f, 0x00000000, 0x00000000,

0x00000004, 0x00002028, 0x00000000, 0x00000000, 0x80000000, 0x00003e0f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 };

int charsHeight = 10;

int charsDivisor = 1; // Every char is separated from the consecutive by a 1 pixel divisor, horizontally and vertically

int charsWidth[224] = { 3, 1, 4, 6, 5, 7, 6, 2, 3, 3, 5, 5, 2, 4, 1, 7, 5, 2, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 3, 4, 3, 6,

7, 6, 6, 6, 6, 6, 6, 6, 6, 3, 5, 6, 5, 7, 6, 6, 6, 6, 6, 6, 7, 6, 7, 7, 6, 6, 6, 2, 7, 2, 3, 5,

2, 5, 5, 5, 5, 5, 4, 5, 5, 1, 2, 5, 2, 5, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 3, 1, 3, 4, 4,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 5, 5, 5, 7, 1, 5, 3, 7, 3, 5, 4, 1, 7, 4, 3, 5, 3, 3, 2, 5, 6, 1, 2, 2, 3, 5, 6, 6, 6, 6,

6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 3, 3, 3, 3, 7, 6, 6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 6, 4, 6,

5, 5, 5, 5, 5, 5, 9, 5, 5, 5, 5, 5, 2, 2, 3, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 5 };

// Re-construct image from defaultFontData and generate OpenGL texture

//----------------------------------------------------------------------

Image imFont = {

.data = RL_CALLOC(128*128, 2), // 2 bytes per pixel (gray + alpha)

.width = 128,

.height = 128,

.mipmaps = 1,

.format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA

};

// Fill image.data with defaultFontData (convert from bit to pixel!)

for (int i = 0, counter = 0; i < imFont.width*imFont.height; i += 32)

{

for (int j = 31; j >= 0; j--)

{

if (BIT_CHECK(defaultFontData[counter], j))

{

// NOTE: Unreferencing data as short, so,

// considering data as little-endian (alpha + gray)

((unsigned short *)imFont.data)[i + j] = 0xffff;

}

else

{

((unsigned char *)imFont.data)[(i + j)*sizeof(short)] = 0xff;

((unsigned char *)imFont.data)[(i + j)*sizeof(short) + 1] = 0x00;

}

}

counter++;

}

defaultFont.texture = LoadTextureFromImage(imFont);

// Check again if font glyph data has been already loaded

// to avoid reallocating the glyphs and rects

if (defaultFont.glyphs != NULL)

{

UnloadImage(imFont);

return;

}

// Reconstruct charSet using charsWidth[], charsHeight, charsDivisor, glyphCount

//------------------------------------------------------------------------------

// Allocate space for our characters info data

// NOTE: This memory must be freed at end! --> Done by CloseWindow()

defaultFont.glyphs = (GlyphInfo *)RL_CALLOC(defaultFont.glyphCount, sizeof(GlyphInfo));

defaultFont.recs = (Rectangle *)RL_CALLOC(defaultFont.glyphCount, sizeof(Rectangle));

int currentLine = 0;

int currentPosX = charsDivisor;

int testPosX = charsDivisor;

for (int i = 0; i < defaultFont.glyphCount; i++)

{

defaultFont.glyphs[i].value = 32 + i; // First char is 32

defaultFont.recs[i].x = (float)currentPosX;

defaultFont.recs[i].y = (float)(charsDivisor + currentLine*(charsHeight + charsDivisor));

defaultFont.recs[i].width = (float)charsWidth[i];

defaultFont.recs[i].height = (float)charsHeight;

testPosX += (int)(defaultFont.recs[i].width + (float)charsDivisor);

if (testPosX >= imFont.width)

{

currentLine++;

currentPosX = 2*charsDivisor + charsWidth[i];

testPosX = currentPosX;

defaultFont.recs[i].x = (float)charsDivisor;

defaultFont.recs[i].y = (float)(charsDivisor + currentLine*(charsHeight + charsDivisor));

}

else currentPosX = testPosX;

// NOTE: On default font character offsets and xAdvance are not required

defaultFont.glyphs[i].offsetX = 0;

defaultFont.glyphs[i].offsetY = 0;

defaultFont.glyphs[i].advanceX = 0;

// Fill character image data from fontClear data

defaultFont.glyphs[i].image = ImageFromImage(imFont, defaultFont.recs[i]);

}

UnloadImage(imFont);

defaultFont.baseSize = (int)defaultFont.recs[0].height;

TRACELOG(LOG_INFO, "FONT: Default font loaded successfully (%i glyphs)", defaultFont.glyphCount);

}

extern void UnloadFontDefault(void)

{

for (int i = 0; i < defaultFont.glyphCount; i++) UnloadImage(defaultFont.glyphs[i].image);

UnloadTexture(defaultFont.texture);

RL_FREE(defaultFont.glyphs);

RL_FREE(defaultFont.recs);

defaultFont.glyphCount = 0;

defaultFont.glyphs = NULL;

defaultFont.recs = NULL;

}

Font GetFontDefault()

{

return defaultFont;

}

Font LoadFont(const char *fileName)

{

// Default values for ttf font generation

#ifndef FONT_TTF_DEFAULT_SIZE

#define FONT_TTF_DEFAULT_SIZE 32 // TTF font generation default char size (char-height)

#ifndef FONT_TTF_DEFAULT_NUMCHARS

#define FONT_TTF_DEFAULT_NUMCHARS 95 // TTF font generation default charset: 95 glyphs (ASCII 32..126)

#ifndef FONT_TTF_DEFAULT_FIRST_CHAR

#define FONT_TTF_DEFAULT_FIRST_CHAR 32 // TTF font generation default first char for image sprite font (32-Space)

#ifndef FONT_TTF_DEFAULT_CHARS_PADDING

#define FONT_TTF_DEFAULT_CHARS_PADDING 4 // TTF font generation default glyphs padding

Font font = { 0 };

#if SUPPORT_FILEFORMAT_TTF

if (IsFileExtension(fileName, ".ttf") || IsFileExtension(fileName, ".otf")) font = LoadFontEx(fileName, FONT_TTF_DEFAULT_SIZE, NULL, FONT_TTF_DEFAULT_NUMCHARS);

else

#if SUPPORT_FILEFORMAT_FNT

if (IsFileExtension(fileName, ".fnt")) font = LoadBMFont(fileName);

else

#if SUPPORT_FILEFORMAT_BDF

if (IsFileExtension(fileName, ".bdf")) font = LoadFontEx(fileName, FONT_TTF_DEFAULT_SIZE, NULL, FONT_TTF_DEFAULT_NUMCHARS);

else

{

Image image = LoadImage(fileName);

if (image.data != NULL) font = LoadFontFromImage(image, MAGENTA, FONT_TTF_DEFAULT_FIRST_CHAR);

else font = GetFontDefault();

UnloadImage(image);

}

if (font.texture.id == 0) TRACELOG(LOG_WARNING, "FONT: [%s] Failed to load font texture -> Using default font", fileName);

else

{

SetTextureFilter(font.texture, TEXTURE_FILTER_POINT); // By default, set point filter (the best performance)

TRACELOG(LOG_INFO, "FONT: Data loaded successfully (%i pixel size | %i glyphs)", font.baseSize, font.glyphCount);

}

return font;

}

Font LoadFontEx(const char *fileName, int fontSize, const int *codepoints, int codepointCount)

{

Font font = { 0 };

// Loading file to memory

int dataSize = 0;

unsigned char *fileData = LoadFileData(fileName, &dataSize);

if (fileData != NULL)

{

// Loading font from memory data

font = LoadFontFromMemory(GetFileExtension(fileName), fileData, dataSize, fontSize, codepoints, codepointCount);

UnloadFileData(fileData);

}

return font;

}

Font LoadFontFromImage(Image image, Color key, int firstChar)

{

#ifndef MAX_GLYPHS_FROM_IMAGE

#define MAX_GLYPHS_FROM_IMAGE 256 // Maximum number of glyphs supported on image scan

#define COLOR_EQUAL(col1, col2) ((col1.r == col2.r) && (col1.g == col2.g) && (col1.b == col2.b) && (col1.a == col2.a))

Font font = GetFontDefault();

int charSpacing = 0;

int lineSpacing = 0;

int x = 0;

int y = 0;

// Allocate a temporal arrays for glyphs data measures,

// once the actual number of glyphs is obtained, copy data to a sized array

int tempCharValues[MAX_GLYPHS_FROM_IMAGE] = { 0 };

Rectangle tempCharRecs[MAX_GLYPHS_FROM_IMAGE] = { 0 };

Color *pixels = LoadImageColors(image);

// Parse image data to get charSpacing and lineSpacing

for (y = 0; y < image.height; y++)

{

for (x = 0; x < image.width; x++)

{

if (!COLOR_EQUAL(pixels[y*image.width + x], key)) break;

}

if (!COLOR_EQUAL(pixels[y*image.width + x], key)) break;

}

if ((x == 0) || (y == 0)) return font; // Security check

charSpacing = x;

lineSpacing = y;

int charHeight = 0;

int j = 0;

while (((lineSpacing + j) < image.height) &&

!COLOR_EQUAL(pixels[(lineSpacing + j)*image.width + charSpacing], key)) j++;

charHeight = j;

// Check array values to get characters: value, x, y, w, h

int index = 0;

int lineToRead = 0;

int xPosToRead = charSpacing;

// Parse image data to get rectangle sizes

while ((lineSpacing + lineToRead*(charHeight + lineSpacing)) < image.height)

{

while ((xPosToRead < image.width) &&

!COLOR_EQUAL((pixels[(lineSpacing + (charHeight+lineSpacing)*lineToRead)*image.width + xPosToRead]), key))

{

tempCharValues[index] = firstChar + index;

tempCharRecs[index].x = (float)xPosToRead;

tempCharRecs[index].y = (float)(lineSpacing + lineToRead*(charHeight + lineSpacing));

tempCharRecs[index].height = (float)charHeight;

int charWidth = 0;

while (((xPosToRead + charWidth) < image.width) &&

!COLOR_EQUAL(pixels[(lineSpacing + (charHeight + lineSpacing)*lineToRead)*image.width + xPosToRead + charWidth], key)) charWidth++;

tempCharRecs[index].width = (float)charWidth;

index++;

xPosToRead += (charWidth + charSpacing);

}

lineToRead++;

xPosToRead = charSpacing;

}

// NOTE: Key color borders need to be removed from image to avoid weird

// artifacts on texture scaling when using TEXTURE_FILTER_BILINEAR or TEXTURE_FILTER_TRILINEAR

for (int i = 0; i < image.height*image.width; i++) if (COLOR_EQUAL(pixels[i], key)) pixels[i] = BLANK;

// Create a new image with the processed color data (key color replaced by BLANK)

Image fontClear = {

.data = pixels,

.width = image.width,

.height = image.height,

.mipmaps = 1,

.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8

};

// Set font with all data parsed from image

font.texture = LoadTextureFromImage(fontClear); // Convert processed image to OpenGL texture

font.glyphCount = index;

font.glyphPadding = 0;

// Populate tempCharValues and tempCharsRecs with glyphs data

// Move temp data to sized charValues and charRecs arrays

font.glyphs = (GlyphInfo *)RL_MALLOC(font.glyphCount*sizeof(GlyphInfo));

font.recs = (Rectangle *)RL_MALLOC(font.glyphCount*sizeof(Rectangle));

for (int i = 0; i < font.glyphCount; i++)

{

font.glyphs[i].value = tempCharValues[i];

// Get character rectangle in the font atlas texture

font.recs[i] = tempCharRecs[i];

// NOTE: On image based fonts (XNA style), character offsets and xAdvance are not required (set to 0)

font.glyphs[i].offsetX = 0;

font.glyphs[i].offsetY = 0;

font.glyphs[i].advanceX = 0;

// Fill character image data from fontClear data

font.glyphs[i].image = ImageFromImage(fontClear, tempCharRecs[i]);

}

UnloadImage(fontClear); // Unload processed image once converted to texture

font.baseSize = (int)font.recs[0].height;

return font;

}

Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount)

{

Font font = { 0 };

char fileExtLower[16] = { 0 };

strncpy(fileExtLower, TextToLower(fileType), 16 - 1);

font.baseSize = fontSize;

font.glyphPadding = 0;

#if SUPPORT_FILEFORMAT_TTF

if (TextIsEqual(fileExtLower, ".ttf") ||

TextIsEqual(fileExtLower, ".otf"))

{

font.glyphs = LoadFontData(fileData, dataSize, font.baseSize, codepoints, (codepointCount > 0)? codepointCount : 95, FONT_DEFAULT, &font.glyphCount);

}

else

#if SUPPORT_FILEFORMAT_BDF

if (TextIsEqual(fileExtLower, ".bdf"))

{

font.glyphs = LoadFontDataBDF(fileData, dataSize, codepoints, (codepointCount > 0)? codepointCount : 95, &font.baseSize);

font.glyphCount = (codepointCount > 0)? codepointCount : 95;

}

else

{

font.glyphs = NULL;

}

#if SUPPORT_FILEFORMAT_TTF || SUPPORT_FILEFORMAT_BDF

if (font.glyphs != NULL)

{

font.glyphPadding = FONT_TTF_DEFAULT_CHARS_PADDING;

Image atlas = GenImageFontAtlas(font.glyphs, &font.recs, font.glyphCount, font.baseSize, font.glyphPadding, 0);

font.texture = LoadTextureFromImage(atlas);

// Update glyphs[i].image to use alpha, required to be used on ImageDrawText()

for (int i = 0; i < font.glyphCount; i++)

{

UnloadImage(font.glyphs[i].image);

font.glyphs[i].image = ImageFromImage(atlas, font.recs[i]);

}

UnloadImage(atlas);

TRACELOG(LOG_INFO, "FONT: Data loaded successfully (%i pixel size | %i glyphs)", font.baseSize, font.glyphCount);

}

else font = GetFontDefault();

font = GetFontDefault();

return font;

}

bool IsFontValid(Font font)

{

return ((font.baseSize > 0) && // Validate font size

(font.glyphCount > 0) && // Validate font contains some glyph

(font.recs != NULL) && // Validate font recs defining glyphs on texture atlas

(font.glyphs != NULL)); // Validate glyph data is loaded

// NOTE: Further validations could be done to verify if recs and glyphs contain valid data (glyphs values, metrics...)

}

GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount, int type, int *glyphCount)

{

// NOTE: Using some SDF generation default values,

// trades off precision with ability to handle *smaller* sizes

#ifndef FONT_SDF_CHAR_PADDING

#define FONT_SDF_CHAR_PADDING 4 // SDF font generation char padding

#ifndef FONT_SDF_ON_EDGE_VALUE

#define FONT_SDF_ON_EDGE_VALUE 128 // SDF font generation on edge value

#ifndef FONT_SDF_PIXEL_DIST_SCALE

#define FONT_SDF_PIXEL_DIST_SCALE 64.0f // SDF font generation pixel distance scale

#ifndef FONT_BITMAP_ALPHA_THRESHOLD

#define FONT_BITMAP_ALPHA_THRESHOLD 80 // Bitmap (B&W) font generation alpha threshold

GlyphInfo *glyphs = NULL;

int glyphCounter = 0;

#if SUPPORT_FILEFORMAT_TTF

// Load font data (including pixel data) from TTF memory file

// NOTE: Loaded information should be enough to generate font image atlas, using any packaging method

if (fileData != NULL)

{

bool genFontChars = false;

stbtt_fontinfo fontInfo = { 0 };

// TODO: Should a shallow copy be created to avoid "dealing" with a const user array?

int *requiredCodepoints = (int *)codepoints;

if (stbtt_InitFont(&fontInfo, (unsigned char *)fileData, 0)) // Initialize font for data reading

{

// Calculate font scale factor

float scaleFactor = stbtt_ScaleForPixelHeight(&fontInfo, (float)fontSize);

// Calculate font basic metrics

// NOTE: ascent is equivalent to font baseline

int ascent = 0;

int descent = 0;

int lineGap = 0;

stbtt_GetFontVMetrics(&fontInfo, &ascent, &descent, &lineGap);

// In case no chars count provided, default to 95

codepointCount = (codepointCount > 0)? codepointCount : 95;

// Fill fontChars in case not provided externally

// NOTE: By default filling glyphCount consecutively, starting at 32 (Space)

if (requiredCodepoints == NULL)

{

requiredCodepoints = (int *)RL_MALLOC(codepointCount*sizeof(int));

for (int i = 0; i < codepointCount; i++) requiredCodepoints[i] = i + 32;

genFontChars = true;

}

// Check available glyphs on provided font before loading them

for (int i = 0, index; i < codepointCount; i++)

{

index = stbtt_FindGlyphIndex(&fontInfo, requiredCodepoints[i]);

if (index > 0) glyphCounter++;

}

// WARNING: Allocating space for maximum number of codepoints

glyphs = (GlyphInfo *)RL_CALLOC(glyphCounter, sizeof(GlyphInfo));

glyphCounter = 0; // Reset to reuse

int k = 0;

for (int i = 0; i < codepointCount; i++)

{

int cpWidth = 0, cpHeight = 0; // Codepoint width and height (on generation)

int cp = requiredCodepoints[i]; // Codepoint value to get info for

// Render a unicode codepoint to a bitmap

// stbtt_GetCodepointBitmap() -- allocates and returns a bitmap

// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be

// stbtt_MakeCodepointBitmap() -- renders into a provided bitmap

// Check if a glyph is available in the font

// WARNING: if (index == 0), glyph not found, it could fallback to default .notdef glyph (if defined in font)

int index = stbtt_FindGlyphIndex(&fontInfo, cp);

if (index > 0)

{

// NOTE: Only storing glyphs for codepoints found in the font

glyphs[k].value = cp;

switch (type)

{

case FONT_DEFAULT:

case FONT_BITMAP:

{

glyphs[k].image.data = stbtt_GetCodepointBitmap(&fontInfo, scaleFactor, scaleFactor, cp,

&cpWidth, &cpHeight, &glyphs[k].offsetX, &glyphs[k].offsetY);

} break;

case FONT_SDF:

{

if (cp != 32)

{

glyphs[k].image.data = stbtt_GetCodepointSDF(&fontInfo, scaleFactor, cp,

FONT_SDF_CHAR_PADDING, FONT_SDF_ON_EDGE_VALUE, FONT_SDF_PIXEL_DIST_SCALE,

&cpWidth, &cpHeight, &glyphs[k].offsetX, &glyphs[k].offsetY);

}

} break;

//case FONT_MSDF:

default: break;

}

if (glyphs[k].image.data != NULL) // Glyph data has been found in the font

{

stbtt_GetCodepointHMetrics(&fontInfo, cp, &glyphs[k].advanceX, NULL);

glyphs[k].advanceX = (int)((float)glyphs[k].advanceX*scaleFactor);

// WARNING: If requested SDF font, sdf-glyph height is definitely bigger than fontSize due to FONT_SDF_CHAR_PADDING

if ((type != FONT_SDF) && (cpHeight > fontSize)) TRACELOG(LOG_WARNING, "FONT: [0x%04x] Glyph height is bigger than requested font size: %i > %i", cp, cpHeight, (int)fontSize);

// Load glyph image

glyphs[k].image.width = cpWidth;

glyphs[k].image.height = cpHeight;

glyphs[k].image.mipmaps = 1;

glyphs[k].image.format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE;

glyphs[k].offsetY += (int)((float)ascent*scaleFactor);

}

//else TRACELOG(LOG_WARNING, "FONT: Glyph [0x%08x] has no image data available", cp); // Only reported for 0x20 and 0x3000

// Create an empty image for Space character (0x20), useful for sprite font generation

// NOTE: Another space to consider: 0x3000 (CJK - Ideographic Space)

if ((cp == 0x20) || (cp == 0x3000))

{

stbtt_GetCodepointHMetrics(&fontInfo, cp, &glyphs[k].advanceX, NULL);

glyphs[k].advanceX = (int)((float)glyphs[k].advanceX*scaleFactor);

Image imSpace = {

.data = NULL,

.width = glyphs[k].advanceX,

.height = fontSize,

.mipmaps = 1,

.format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE

};

// Only allocate space image if required

if (glyphs[k].advanceX > 0) imSpace.data = RL_CALLOC(glyphs[k].advanceX*fontSize, 1);

else glyphs[k].advanceX = 0;

glyphs[k].image = imSpace;

}

if (type == FONT_BITMAP)

{

// Aliased bitmap (black & white) font generation, avoiding anti-aliasing

// NOTE: For optimum results, bitmap font should be generated at base pixel size

for (int p = 0; p < cpWidth*cpHeight; p++)

{

if (((unsigned char *)glyphs[k].image.data)[p] < FONT_BITMAP_ALPHA_THRESHOLD)

((unsigned char *)glyphs[k].image.data)[p] = 0;

else ((unsigned char *)glyphs[k].image.data)[p] = 255;

}

}

k++;

glyphCounter++;

}

else

{

// WARNING: Glyph not found on font, optionally use a fallback glyph

}

}

if (glyphCounter < codepointCount) TRACELOG(LOG_WARNING, "FONT: Requested codepoints glyphs found: [%i/%i]", k, codepointCount);

}

else TRACELOG(LOG_WARNING, "FONT: Failed to process TTF font data");

if (genFontChars) RL_FREE(requiredCodepoints);

}

*glyphCount = glyphCounter;

return glyphs;

}

#if SUPPORT_FILEFORMAT_TTF || SUPPORT_FILEFORMAT_BDF

Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod)

{

Image atlas = { 0 };

if (glyphs == NULL)

{

TRACELOG(LOG_WARNING, "FONT: Provided glyphs info not valid, returning empty image atlas");

return atlas;

}

*glyphRecs = NULL;

// In case no chars count provided, suppose default of 95

glyphCount = (glyphCount > 0)? glyphCount : 95;

// NOTE: Rectangles memory is loaded here!

Rectangle *recs = (Rectangle *)RL_MALLOC(glyphCount*sizeof(Rectangle));

// Calculate image size based on total glyph width and glyph row count

int totalWidth = 0;

int maxGlyphWidth = 0;

for (int i = 0; i < glyphCount; i++)

{

if (glyphs[i].image.width > maxGlyphWidth) maxGlyphWidth = glyphs[i].image.width;

totalWidth += glyphs[i].image.width + 2*padding;

}

int paddedFontSize = fontSize + 2*padding;

// Estimate image atlas size from available data

// NOTE: Multiplying total expected area by 1.2f scale factor but in case

// some glyphs do not fit, the atlas height is scaled x2 to fit them

float totalArea = totalWidth*paddedFontSize*1.2f;

float imageMinSize = sqrtf(totalArea);

int imageSize = (int)powf(2, ceilf(logf(imageMinSize)/logf(2)));

if (totalArea < ((imageSize*imageSize)/2))

{

atlas.width = imageSize; // Atlas bitmap width

atlas.height = imageSize/2; // Atlas bitmap height

}

else

{

atlas.width = imageSize; // Atlas bitmap width

atlas.height = imageSize; // Atlas bitmap height

}

int atlasDataSize = atlas.width*atlas.height; // Save total size for bounds checking

atlas.data = (unsigned char *)RL_CALLOC(atlasDataSize, 1); // Create a bitmap to store characters (8 bpp)

atlas.format = PIXELFORMAT_UNCOMPRESSED_GRAYSCALE;

atlas.mipmaps = 1;

// DEBUG: View padding in the generated image setting a gray background...

//for (int i = 0; i < atlas.width*atlas.height; i++) ((unsigned char *)atlas.data)[i] = 100;

if (packMethod == 0) // Use basic packing algorithm

{

int offsetX = padding;

int offsetY = padding;

// NOTE: Using simple packaging, one char after another

for (int i = 0; i < glyphCount; i++)

{

// Check remaining space for glyph

if (offsetX >= (atlas.width - glyphs[i].image.width - 2*padding))

{

offsetX = padding;

// NOTE: Be careful on offsetY for SDF fonts, by default SDF

// use an internal padding of 4 pixels, it means char rectangle

// height is bigger than fontSize, it could be up to (fontSize + 8)

offsetY += (fontSize + 2*padding);

if (offsetY > (atlas.height - fontSize - padding))

{

TRACELOG(LOG_WARNING, "FONT: Updating atlas size to fit all characters");

// Update atlas size to fit all characters

int updatedAtlasHeight = atlas.height*2;

int updatedAtlasDataSize = atlas.width*updatedAtlasHeight;

unsigned char *updatedAtlasData = (unsigned char *)RL_CALLOC(updatedAtlasDataSize, 1);

memcpy(updatedAtlasData, atlas.data, atlasDataSize);

RL_FREE(atlas.data);

atlas.data = updatedAtlasData;

atlas.height = updatedAtlasHeight;

atlasDataSize = updatedAtlasDataSize;

}

}

// Copy pixel data from glyph image to atlas

for (int y = 0; y < glyphs[i].image.height; y++)

{

for (int x = 0; x < glyphs[i].image.width; x++)

{

int destX = offsetX + x;

int destY = offsetY + y;

// Security: check both lower and upper bounds

if ((destX >= 0) && (destX < atlas.width) && (destY >= 0) && (destY < atlas.height))

{

((unsigned char *)atlas.data)[destY*atlas.width + destX] =

((unsigned char *)glyphs[i].image.data)[y*glyphs[i].image.width + x];

}

}

}

// Fill chars rectangles in atlas info

recs[i].x = (float)offsetX;

recs[i].y = (float)offsetY;

recs[i].width = (float)glyphs[i].image.width;

recs[i].height = (float)glyphs[i].image.height;

// Move atlas position X for next character drawing

offsetX += (glyphs[i].image.width + 2*padding);

}

}

else if (packMethod == 1) // Use Skyline rect packing algorithm (stb_pack_rect)

{

stbrp_context *context = (stbrp_context *)RL_MALLOC(sizeof(*context));

stbrp_node *nodes = (stbrp_node *)RL_MALLOC(glyphCount*sizeof(*nodes));

stbrp_init_target(context, atlas.width, atlas.height, nodes, glyphCount);

stbrp_rect *rects = (stbrp_rect *)RL_MALLOC(glyphCount*sizeof(stbrp_rect));

// Fill rectangles for packaging

for (int i = 0; i < glyphCount; i++)

{

rects[i].id = i;

rects[i].w = glyphs[i].image.width + 2*padding;

rects[i].h = glyphs[i].image.height + 2*padding;

}

// Package rectangles into atlas

stbrp_pack_rects(context, rects, glyphCount);

for (int i = 0; i < glyphCount; i++)

{

// It returns char rectangles in atlas

recs[i].x = rects[i].x + (float)padding;

recs[i].y = rects[i].y + (float)padding;

recs[i].width = (float)glyphs[i].image.width;

recs[i].height = (float)glyphs[i].image.height;

if (rects[i].was_packed)

{

// Copy pixel data from fc.data to atlas

for (int y = 0; y < glyphs[i].image.height; y++)

{

for (int x = 0; x < glyphs[i].image.width; x++)

{

int destX = rects[i].x + padding + x;

int destY = rects[i].y + padding + y;

// Security fix: check both lower and upper bounds

if (destX >= 0 && destX < atlas.width && destY >= 0 && destY < atlas.height)

{

((unsigned char *)atlas.data)[destY * atlas.width + destX] =

((unsigned char *)glyphs[i].image.data)[y * glyphs[i].image.width + x];

}

}

}

}

else TRACELOG(LOG_WARNING, "FONT: Failed to package glyph (0x%02x)", glyphs[i].value);

}

RL_FREE(rects);

RL_FREE(nodes);

RL_FREE(context);

}

// Add a 3x3 white rectangle at the bottom-right corner of the generated atlas,

// useful to use as the white texture to draw shapes with raylib

// Security: ensure the atlas is large enough to hold a 3x3 rectangle

if ((FONT_ATLAS_CORNER_REC_SIZE > 0) && (atlas.width >= 3) && (atlas.height >= 3))

{

for (int i = 0, k = atlas.width*atlas.height - 1; i < FONT_ATLAS_CORNER_REC_SIZE; i++)

{

((unsigned char *)atlas.data)[k - 0] = 255;

((unsigned char *)atlas.data)[k - 1] = 255;

((unsigned char *)atlas.data)[k - 2] = 255;

k -= atlas.width;

}

}

// Convert image data from GRAYSCALE to GRAY_ALPHA

unsigned char *dataGrayAlpha = (unsigned char *)RL_MALLOC(atlas.width*atlas.height*sizeof(unsigned char)*2); // Two channels

for (int i = 0, k = 0; i < atlas.width*atlas.height; i++, k += 2)

{

dataGrayAlpha[k] = 255;

dataGrayAlpha[k + 1] = ((unsigned char *)atlas.data)[i];

}

RL_FREE(atlas.data);

atlas.data = dataGrayAlpha;

atlas.format = PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA;

*glyphRecs = recs;

return atlas;

}

void UnloadFontData(GlyphInfo *glyphs, int glyphCount)

{

if (glyphs != NULL)

{

for (int i = 0; i < glyphCount; i++) UnloadImage(glyphs[i].image);

RL_FREE(glyphs);

}