2014-09-17 00:51:31 +04:00
|
|
|
/**********************************************************************************************
|
2013-11-19 02:38:44 +04:00
|
|
|
*
|
2018-05-04 17:59:48 +03:00
|
|
|
* raylib.text - Basic functions to load Fonts and draw Text
|
2013-11-19 02:38:44 +04:00
|
|
|
*
|
2017-02-16 02:50:02 +03:00
|
|
|
* CONFIGURATION:
|
2014-09-03 18:51:28 +04:00
|
|
|
*
|
2017-02-16 02:50:02 +03:00
|
|
|
* #define SUPPORT_FILEFORMAT_FNT
|
2017-03-26 23:49:01 +03:00
|
|
|
* #define SUPPORT_FILEFORMAT_TTF
|
2018-04-07 23:29:53 +03:00
|
|
|
* Selected desired fileformats to be supported for loading. Some of those formats are
|
2017-02-16 02:50:02 +03:00
|
|
|
* supported by default, to remove support, just comment unrequired #define in this module
|
|
|
|
*
|
2017-03-21 15:22:47 +03:00
|
|
|
* #define SUPPORT_DEFAULT_FONT
|
2019-10-22 01:37:10 +03:00
|
|
|
* Load default raylib font on initialization to be used by DrawText() and MeasureText().
|
|
|
|
* If no default font loaded, DrawTextEx() and MeasureTextEx() are required.
|
|
|
|
*
|
|
|
|
* #define TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH
|
|
|
|
* TextSplit() function static buffer max size
|
|
|
|
*
|
|
|
|
* #define TEXTSPLIT_MAX_SUBSTRINGS_COUNT
|
|
|
|
* TextSplit() function static substrings pointers array (pointing to static buffer)
|
|
|
|
*
|
2017-02-16 02:50:02 +03:00
|
|
|
*
|
|
|
|
* DEPENDENCIES:
|
2019-10-23 00:15:26 +03:00
|
|
|
* stb_truetype - Load TTF file and rasterize characters data
|
|
|
|
* stb_rect_pack - Rectangles packing algorythms, required for font atlas generation
|
2016-11-16 20:46:13 +03:00
|
|
|
*
|
2017-02-16 02:50:02 +03:00
|
|
|
*
|
|
|
|
* LICENSE: zlib/libpng
|
2016-11-16 20:46:13 +03:00
|
|
|
*
|
2019-04-08 13:25:13 +03:00
|
|
|
* Copyright (c) 2013-2019 Ramon Santamaria (@raysan5)
|
2014-03-16 23:59:02 +04:00
|
|
|
*
|
2014-09-03 18:51:28 +04:00
|
|
|
* This software is provided "as-is", without any express or implied warranty. In no event
|
2013-11-23 16:30:54 +04:00
|
|
|
* will the authors be held liable for any damages arising from the use of this software.
|
2013-11-19 02:38:44 +04:00
|
|
|
*
|
2014-09-03 18:51:28 +04:00
|
|
|
* Permission is granted to anyone to use this software for any purpose, including commercial
|
2013-11-23 16:30:54 +04:00
|
|
|
* applications, and to alter it and redistribute it freely, subject to the following restrictions:
|
2013-11-19 02:38:44 +04:00
|
|
|
*
|
2014-09-03 18:51:28 +04:00
|
|
|
* 1. The origin of this software must not be misrepresented; you must not claim that you
|
|
|
|
* wrote the original software. If you use this software in a product, an acknowledgment
|
2013-11-23 16:30:54 +04:00
|
|
|
* in the product documentation would be appreciated but is not required.
|
2013-11-19 02:38:44 +04:00
|
|
|
*
|
2013-11-23 16:30:54 +04:00
|
|
|
* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
|
|
|
|
* as being the original software.
|
2013-11-19 02:38:44 +04:00
|
|
|
*
|
2013-11-23 16:30:54 +04:00
|
|
|
* 3. This notice may not be removed or altered from any source distribution.
|
2013-11-19 02:38:44 +04:00
|
|
|
*
|
|
|
|
**********************************************************************************************/
|
|
|
|
|
2018-05-17 01:04:36 +03:00
|
|
|
#include "raylib.h" // Declares module functions
|
2013-11-19 02:38:44 +04:00
|
|
|
|
2018-12-18 02:20:08 +03:00
|
|
|
// Check if config flags have been externally provided on compilation line
|
|
|
|
#if !defined(EXTERNAL_CONFIG_FLAGS)
|
2019-10-23 00:15:26 +03:00
|
|
|
#include "config.h" // Defines module configuration flags
|
2018-12-18 02:20:08 +03:00
|
|
|
#endif
|
|
|
|
|
2016-06-02 02:26:44 +03:00
|
|
|
#include <stdlib.h> // Required for: malloc(), free()
|
|
|
|
#include <string.h> // Required for: strlen()
|
|
|
|
#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end()
|
|
|
|
#include <stdio.h> // Required for: FILE, fopen(), fclose(), fscanf(), feof(), rewind(), fgets()
|
2018-12-26 15:26:34 +03:00
|
|
|
#include <ctype.h> // Required for: toupper(), tolower()
|
2013-11-19 02:38:44 +04:00
|
|
|
|
2017-04-21 01:08:00 +03:00
|
|
|
#include "utils.h" // Required for: fopen() Android mapping
|
2014-04-19 18:36:49 +04:00
|
|
|
|
2017-03-26 23:49:01 +03:00
|
|
|
#if defined(SUPPORT_FILEFORMAT_TTF)
|
2018-06-20 01:52:14 +03:00
|
|
|
#define STB_RECT_PACK_IMPLEMENTATION
|
|
|
|
#include "external/stb_rect_pack.h" // Required for: ttf font rectangles packaging
|
|
|
|
|
|
|
|
#define STBTT_STATIC
|
2017-03-26 23:49:01 +03:00
|
|
|
#define STB_TRUETYPE_IMPLEMENTATION
|
2018-06-20 01:52:14 +03:00
|
|
|
#include "external/stb_truetype.h" // Required for: ttf font data reading
|
2017-03-26 23:49:01 +03:00
|
|
|
#endif
|
2015-01-18 12:58:04 +03:00
|
|
|
|
2013-11-19 02:38:44 +04:00
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Defines and Macros
|
|
|
|
//----------------------------------------------------------------------------------
|
2019-10-22 01:37:10 +03:00
|
|
|
#define MAX_TEXT_BUFFER_LENGTH 1024 // Size of internal static buffers used on some functions:
|
|
|
|
// TextFormat(), TextSubtext(), TextToUpper(), TextToLower(), TextToPascal()
|
2013-11-19 02:38:44 +04:00
|
|
|
|
2019-10-11 21:12:15 +03:00
|
|
|
#define MAX_TEXT_UNICODE_CHARS 512 // Maximum number of unicode codepoints
|
|
|
|
|
2019-10-22 01:37:10 +03:00
|
|
|
#if !defined(TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH)
|
|
|
|
#define TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH 1024 // Size of static buffer: TextSplit()
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if !defined(TEXTSPLIT_MAX_SUBSTRINGS_COUNT)
|
|
|
|
#define TEXTSPLIT_MAX_SUBSTRINGS_COUNT 128 // Size of static pointers array: TextSplit()
|
|
|
|
#endif
|
|
|
|
|
2013-11-19 02:38:44 +04:00
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Types and Structures Definition
|
|
|
|
//----------------------------------------------------------------------------------
|
2014-11-23 23:58:17 +03:00
|
|
|
// ...
|
2014-04-09 22:25:26 +04:00
|
|
|
|
2013-11-19 02:38:44 +04:00
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Global variables
|
|
|
|
//----------------------------------------------------------------------------------
|
2017-03-21 15:22:47 +03:00
|
|
|
#if defined(SUPPORT_DEFAULT_FONT)
|
2019-06-19 16:43:35 +03:00
|
|
|
static Font defaultFont = { 0 }; // Default font provided by raylib
|
2013-11-23 16:30:54 +04:00
|
|
|
// NOTE: defaultFont is loaded on InitWindow and disposed on CloseWindow [module: core]
|
2017-03-21 15:22:47 +03:00
|
|
|
#endif
|
2013-11-19 02:38:44 +04:00
|
|
|
|
2014-03-25 15:40:35 +04:00
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Other Modules Functions Declaration (required by text)
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
//...
|
|
|
|
|
2013-11-19 02:38:44 +04:00
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Module specific Functions Declaration
|
|
|
|
//----------------------------------------------------------------------------------
|
2017-03-26 23:49:01 +03:00
|
|
|
#if defined(SUPPORT_FILEFORMAT_FNT)
|
2018-05-04 17:59:48 +03:00
|
|
|
static Font LoadBMFont(const char *fileName); // Load a BMFont file (AngelCode font file)
|
2017-03-26 23:49:01 +03:00
|
|
|
#endif
|
2013-11-19 02:38:44 +04:00
|
|
|
|
2017-03-21 15:22:47 +03:00
|
|
|
#if defined(SUPPORT_DEFAULT_FONT)
|
2019-06-17 00:42:51 +03:00
|
|
|
extern void LoadFontDefault(void);
|
|
|
|
extern void UnloadFontDefault(void);
|
2017-03-21 15:22:47 +03:00
|
|
|
#endif
|
2014-09-17 00:51:31 +04:00
|
|
|
|
2013-11-19 02:38:44 +04:00
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Module Functions Definition
|
|
|
|
//----------------------------------------------------------------------------------
|
2017-03-21 15:22:47 +03:00
|
|
|
#if defined(SUPPORT_DEFAULT_FONT)
|
|
|
|
|
|
|
|
// Load raylib default font
|
2019-06-17 00:42:51 +03:00
|
|
|
extern void LoadFontDefault(void)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
2018-02-25 05:17:57 +03:00
|
|
|
#define BIT_CHECK(a,b) ((a) & (1u << (b)))
|
2017-03-21 15:22:47 +03:00
|
|
|
|
2015-03-09 19:13:42 +03:00
|
|
|
// NOTE: Using UTF8 encoding table for Unicode U+0000..U+00FF Basic Latin + Latin-1 Supplement
|
|
|
|
// http://www.utf8-chartable.de/unicode-utf8-table.pl
|
2015-04-06 15:02:29 +03:00
|
|
|
|
2017-02-05 04:59:39 +03:00
|
|
|
defaultFont.charsCount = 224; // Number of chars included in our default font
|
2014-03-25 15:40:35 +04:00
|
|
|
|
2013-11-23 16:30:54 +04:00
|
|
|
// Default font is directly defined here (data generated from a sprite font image)
|
2018-05-04 17:59:48 +03:00
|
|
|
// This way, we reconstruct Font without creating large global variables
|
2013-11-23 16:30:54 +04:00
|
|
|
// This data is automatically allocated to Stack and automatically deallocated at the end of this function
|
2019-01-24 06:28:10 +03:00
|
|
|
unsigned int defaultFontData[512] = {
|
2015-04-06 15:02:29 +03:00
|
|
|
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,
|
2017-08-06 11:44:50 +03:00
|
|
|
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,
|
2015-04-06 15:02:29 +03:00
|
|
|
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 };
|
2013-11-23 16:30:54 +04:00
|
|
|
|
|
|
|
int charsHeight = 10;
|
|
|
|
int charsDivisor = 1; // Every char is separated from the consecutive by a 1 pixel divisor, horizontally and vertically
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2015-03-09 19:13:42 +03:00
|
|
|
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,
|
2015-04-06 15:02:29 +03:00
|
|
|
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 };
|
2013-11-23 16:30:54 +04:00
|
|
|
|
2014-03-25 15:40:35 +04:00
|
|
|
// Re-construct image from defaultFontData and generate OpenGL texture
|
|
|
|
//----------------------------------------------------------------------
|
2015-05-11 01:15:46 +03:00
|
|
|
int imWidth = 128;
|
|
|
|
int imHeight = 128;
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
Color *imagePixels = (Color *)RL_MALLOC(imWidth*imHeight*sizeof(Color));
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2015-05-11 01:15:46 +03:00
|
|
|
for (int i = 0; i < imWidth*imHeight; i++) imagePixels[i] = BLANK; // Initialize array
|
2014-03-25 15:40:35 +04:00
|
|
|
|
|
|
|
int counter = 0; // Font data elements counter
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2014-03-25 15:40:35 +04:00
|
|
|
// Fill imgData with defaultFontData (convert from bit to pixel!)
|
2015-05-11 01:15:46 +03:00
|
|
|
for (int i = 0; i < imWidth*imHeight; i += 32)
|
2014-03-25 15:40:35 +04:00
|
|
|
{
|
|
|
|
for (int j = 31; j >= 0; j--)
|
|
|
|
{
|
2015-05-05 00:46:31 +03:00
|
|
|
if (BIT_CHECK(defaultFontData[counter], j)) imagePixels[i+j] = WHITE;
|
2014-03-25 15:40:35 +04:00
|
|
|
}
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2014-03-25 15:40:35 +04:00
|
|
|
counter++;
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2015-03-09 19:13:42 +03:00
|
|
|
if (counter > 512) counter = 0; // Security check...
|
2014-03-25 15:40:35 +04:00
|
|
|
}
|
2015-04-06 15:02:29 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
Image imFont = LoadImageEx(imagePixels, imWidth, imHeight);
|
|
|
|
ImageFormat(&imFont, UNCOMPRESSED_GRAY_ALPHA);
|
2015-05-05 00:46:31 +03:00
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
RL_FREE(imagePixels);
|
2014-09-03 18:51:28 +04:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
defaultFont.texture = LoadTextureFromImage(imFont);
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2017-02-05 04:59:39 +03:00
|
|
|
// Reconstruct charSet using charsWidth[], charsHeight, charsDivisor, charsCount
|
2013-11-23 16:30:54 +04:00
|
|
|
//------------------------------------------------------------------------------
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2017-02-05 04:59:39 +03:00
|
|
|
// Allocate space for our characters info data
|
|
|
|
// NOTE: This memory should be freed at end! --> CloseWindow()
|
2019-04-23 15:55:35 +03:00
|
|
|
defaultFont.chars = (CharInfo *)RL_MALLOC(defaultFont.charsCount*sizeof(CharInfo));
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
defaultFont.recs = (Rectangle *)RL_MALLOC(defaultFont.charsCount*sizeof(Rectangle));
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2013-11-23 16:30:54 +04:00
|
|
|
int currentLine = 0;
|
|
|
|
int currentPosX = charsDivisor;
|
|
|
|
int testPosX = charsDivisor;
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2017-02-05 04:59:39 +03:00
|
|
|
for (int i = 0; i < defaultFont.charsCount; i++)
|
2013-11-23 16:30:54 +04:00
|
|
|
{
|
2017-02-05 04:59:39 +03:00
|
|
|
defaultFont.chars[i].value = 32 + i; // First char is 32
|
2016-08-16 12:09:55 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
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;
|
2014-09-03 18:51:28 +04:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
testPosX += (int)(defaultFont.recs[i].width + (float)charsDivisor);
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2013-11-23 16:30:54 +04:00
|
|
|
if (testPosX >= defaultFont.texture.width)
|
|
|
|
{
|
|
|
|
currentLine++;
|
2016-05-03 18:54:50 +03:00
|
|
|
currentPosX = 2*charsDivisor + charsWidth[i];
|
2013-11-23 16:30:54 +04:00
|
|
|
testPosX = currentPosX;
|
2014-09-03 18:51:28 +04:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
defaultFont.recs[i].x = (float)charsDivisor;
|
|
|
|
defaultFont.recs[i].y = (float)(charsDivisor + currentLine*(charsHeight + charsDivisor));
|
2013-11-23 16:30:54 +04:00
|
|
|
}
|
|
|
|
else currentPosX = testPosX;
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
// NOTE: On default font character offsets and xAdvance are not required
|
2017-02-05 04:59:39 +03:00
|
|
|
defaultFont.chars[i].offsetX = 0;
|
|
|
|
defaultFont.chars[i].offsetY = 0;
|
|
|
|
defaultFont.chars[i].advanceX = 0;
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
|
|
|
|
// Fill character image data from fontClear data
|
|
|
|
defaultFont.chars[i].image = ImageFromImage(imFont, defaultFont.recs[i]);
|
2013-11-23 16:30:54 +04:00
|
|
|
}
|
2016-08-16 12:09:55 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
UnloadImage(imFont);
|
|
|
|
|
|
|
|
defaultFont.baseSize = (int)defaultFont.recs[0].height;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2017-07-02 13:35:13 +03:00
|
|
|
TraceLog(LOG_INFO, "[TEX ID %i] Default font loaded successfully", defaultFont.texture.id);
|
2013-11-19 02:38:44 +04:00
|
|
|
}
|
|
|
|
|
2017-03-21 15:22:47 +03:00
|
|
|
// Unload raylib default font
|
2019-06-17 00:42:51 +03:00
|
|
|
extern void UnloadFontDefault(void)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
for (int i = 0; i < defaultFont.charsCount; i++) UnloadImage(defaultFont.chars[i].image);
|
2015-04-06 15:02:29 +03:00
|
|
|
UnloadTexture(defaultFont.texture);
|
2019-04-23 15:55:35 +03:00
|
|
|
RL_FREE(defaultFont.chars);
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
RL_FREE(defaultFont.recs);
|
2013-11-19 02:38:44 +04:00
|
|
|
}
|
2017-03-21 15:22:47 +03:00
|
|
|
#endif // SUPPORT_DEFAULT_FONT
|
2013-11-19 02:38:44 +04:00
|
|
|
|
2013-11-29 23:24:11 +04:00
|
|
|
// Get the default font, useful to be used with extended parameters
|
2018-07-05 20:17:06 +03:00
|
|
|
Font GetFontDefault()
|
2013-11-29 23:24:11 +04:00
|
|
|
{
|
2017-03-21 15:22:47 +03:00
|
|
|
#if defined(SUPPORT_DEFAULT_FONT)
|
2013-11-29 23:24:11 +04:00
|
|
|
return defaultFont;
|
2017-03-21 15:22:47 +03:00
|
|
|
#else
|
2018-05-04 17:59:48 +03:00
|
|
|
Font font = { 0 };
|
2017-03-21 15:22:47 +03:00
|
|
|
return font;
|
2018-11-06 17:10:50 +03:00
|
|
|
#endif
|
2013-11-29 23:24:11 +04:00
|
|
|
}
|
|
|
|
|
2018-05-04 17:59:48 +03:00
|
|
|
// Load Font from file into GPU memory (VRAM)
|
|
|
|
Font LoadFont(const char *fileName)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
2016-08-07 14:38:48 +03:00
|
|
|
// Default hardcoded values for ttf file loading
|
|
|
|
#define DEFAULT_TTF_FONTSIZE 32 // Font first character (32 - space)
|
|
|
|
#define DEFAULT_TTF_NUMCHARS 95 // ASCII 32..126 is 95 glyphs
|
2018-06-20 01:52:14 +03:00
|
|
|
#define DEFAULT_FIRST_CHAR 32 // Expected first char for image sprite font
|
2016-08-07 14:38:48 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
Font font = { 0 };
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2017-03-29 01:02:40 +03:00
|
|
|
#if defined(SUPPORT_FILEFORMAT_TTF)
|
2019-10-11 21:13:11 +03:00
|
|
|
if (IsFileExtension(fileName, ".ttf;.otf")) font = LoadFontEx(fileName, DEFAULT_TTF_FONTSIZE, NULL, DEFAULT_TTF_NUMCHARS);
|
2017-12-14 13:41:31 +03:00
|
|
|
else
|
2017-03-29 01:02:40 +03:00
|
|
|
#endif
|
|
|
|
#if defined(SUPPORT_FILEFORMAT_FNT)
|
2018-06-20 01:52:14 +03:00
|
|
|
if (IsFileExtension(fileName, ".fnt")) font = LoadBMFont(fileName);
|
2013-12-19 15:08:06 +04:00
|
|
|
else
|
2017-12-14 13:41:31 +03:00
|
|
|
#endif
|
2014-09-03 18:51:28 +04:00
|
|
|
{
|
2014-09-17 00:51:31 +04:00
|
|
|
Image image = LoadImage(fileName);
|
2018-12-20 14:58:27 +03:00
|
|
|
if (image.data != NULL) font = LoadFontFromImage(image, MAGENTA, DEFAULT_FIRST_CHAR);
|
2014-03-25 15:40:35 +04:00
|
|
|
UnloadImage(image);
|
2013-12-19 15:08:06 +04:00
|
|
|
}
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
if (font.texture.id == 0)
|
2016-01-02 12:45:51 +03:00
|
|
|
{
|
2018-05-04 17:59:48 +03:00
|
|
|
TraceLog(LOG_WARNING, "[%s] Font could not be loaded, using default font", fileName);
|
2018-07-05 20:17:06 +03:00
|
|
|
font = GetFontDefault();
|
2016-01-02 12:45:51 +03:00
|
|
|
}
|
2018-06-20 01:52:14 +03:00
|
|
|
else SetTextureFilter(font.texture, FILTER_POINT); // By default we set point filter (best performance)
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
return font;
|
2013-11-19 02:38:44 +04:00
|
|
|
}
|
|
|
|
|
2018-06-30 20:58:44 +03:00
|
|
|
// Load Font from TTF font file with generation parameters
|
|
|
|
// NOTE: You can pass an array with desired characters, those characters should be available in the font
|
|
|
|
// if array is NULL, default char set is selected 32..126
|
2018-12-25 17:17:42 +03:00
|
|
|
Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount)
|
2018-06-30 20:58:44 +03:00
|
|
|
{
|
|
|
|
Font font = { 0 };
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-30 20:58:44 +03:00
|
|
|
font.baseSize = fontSize;
|
2019-02-22 15:13:11 +03:00
|
|
|
font.charsCount = (charsCount > 0)? charsCount : 95;
|
2018-09-06 17:56:21 +03:00
|
|
|
font.chars = LoadFontData(fileName, font.baseSize, fontChars, font.charsCount, FONT_DEFAULT);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2019-02-14 13:32:23 +03:00
|
|
|
#if defined(SUPPORT_FILEFORMAT_TTF)
|
2018-10-18 18:48:33 +03:00
|
|
|
if (font.chars != NULL)
|
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
Image atlas = GenImageFontAtlas(font.chars, &font.recs, font.charsCount, font.baseSize, 2, 0);
|
2018-10-18 18:48:33 +03:00
|
|
|
font.texture = LoadTextureFromImage(atlas);
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Update chars[i].image to use alpha, required to be used on ImageDrawText()
|
|
|
|
for (int i = 0; i < font.charsCount; i++)
|
|
|
|
{
|
|
|
|
UnloadImage(font.chars[i].image);
|
|
|
|
font.chars[i].image = ImageFromImage(atlas, font.recs[i]);
|
|
|
|
}
|
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
UnloadImage(atlas);
|
|
|
|
}
|
2018-10-24 14:45:17 +03:00
|
|
|
else font = GetFontDefault();
|
2019-02-14 13:32:23 +03:00
|
|
|
#else
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
UnloadFont(font);
|
2019-02-14 13:32:23 +03:00
|
|
|
font = GetFontDefault();
|
|
|
|
#endif
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-30 20:58:44 +03:00
|
|
|
return font;
|
|
|
|
}
|
|
|
|
|
2018-12-20 14:58:27 +03:00
|
|
|
// Load an Image font file (XNA style)
|
|
|
|
Font LoadFontFromImage(Image image, Color key, int firstChar)
|
|
|
|
{
|
|
|
|
#define COLOR_EQUAL(col1, col2) ((col1.r == col2.r)&&(col1.g == col2.g)&&(col1.b == col2.b)&&(col1.a == col2.a))
|
|
|
|
|
|
|
|
int charSpacing = 0;
|
|
|
|
int lineSpacing = 0;
|
|
|
|
|
|
|
|
int x = 0;
|
|
|
|
int y = 0;
|
|
|
|
|
|
|
|
// Default number of characters supported
|
|
|
|
#define MAX_FONTCHARS 256
|
|
|
|
|
|
|
|
// We allocate a temporal arrays for chars data measures,
|
|
|
|
// once we get the actual number of chars, we copy data to a sized arrays
|
|
|
|
int tempCharValues[MAX_FONTCHARS];
|
|
|
|
Rectangle tempCharRecs[MAX_FONTCHARS];
|
|
|
|
|
|
|
|
Color *pixels = GetImageData(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;
|
|
|
|
}
|
|
|
|
|
|
|
|
charSpacing = x;
|
|
|
|
lineSpacing = y;
|
|
|
|
|
|
|
|
int charHeight = 0;
|
|
|
|
int j = 0;
|
|
|
|
|
|
|
|
while (!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 (!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;
|
|
|
|
}
|
|
|
|
|
|
|
|
TraceLog(LOG_DEBUG, "Font data parsed correctly from image");
|
|
|
|
|
|
|
|
// NOTE: We need to remove key color borders from image to avoid weird
|
|
|
|
// artifacts on texture scaling when using FILTER_BILINEAR or 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 = LoadImageEx(pixels, image.width, image.height);
|
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
RL_FREE(pixels); // Free pixels array memory
|
2018-12-20 14:58:27 +03:00
|
|
|
|
|
|
|
// Create spritefont with all data parsed from image
|
|
|
|
Font spriteFont = { 0 };
|
|
|
|
|
|
|
|
spriteFont.texture = LoadTextureFromImage(fontClear); // Convert processed image to OpenGL texture
|
|
|
|
spriteFont.charsCount = index;
|
|
|
|
|
|
|
|
// We got tempCharValues and tempCharsRecs populated with chars data
|
|
|
|
// Now we move temp data to sized charValues and charRecs arrays
|
2019-04-23 15:55:35 +03:00
|
|
|
spriteFont.chars = (CharInfo *)RL_MALLOC(spriteFont.charsCount*sizeof(CharInfo));
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
spriteFont.recs = (Rectangle *)RL_MALLOC(spriteFont.charsCount*sizeof(Rectangle));
|
2018-12-20 14:58:27 +03:00
|
|
|
|
|
|
|
for (int i = 0; i < spriteFont.charsCount; i++)
|
|
|
|
{
|
|
|
|
spriteFont.chars[i].value = tempCharValues[i];
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Get character rectangle in the font atlas texture
|
|
|
|
spriteFont.recs[i] = tempCharRecs[i];
|
2018-12-20 14:58:27 +03:00
|
|
|
|
|
|
|
// NOTE: On image based fonts (XNA style), character offsets and xAdvance are not required (set to 0)
|
|
|
|
spriteFont.chars[i].offsetX = 0;
|
|
|
|
spriteFont.chars[i].offsetY = 0;
|
|
|
|
spriteFont.chars[i].advanceX = 0;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Fill character image data from fontClear data
|
|
|
|
spriteFont.chars[i].image = ImageFromImage(fontClear, tempCharRecs[i]);
|
2018-12-20 14:58:27 +03:00
|
|
|
}
|
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
UnloadImage(fontClear); // Unload processed image once converted to texture
|
|
|
|
|
|
|
|
spriteFont.baseSize = (int)spriteFont.recs[0].height;
|
2018-12-20 14:58:27 +03:00
|
|
|
|
|
|
|
TraceLog(LOG_INFO, "Image file loaded correctly as Font");
|
|
|
|
|
|
|
|
return spriteFont;
|
|
|
|
}
|
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
// Load font data for further use
|
|
|
|
// NOTE: Requires TTF font and can generate SDF data
|
2018-09-06 17:56:21 +03:00
|
|
|
CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int charsCount, int type)
|
2016-10-27 14:39:47 +03:00
|
|
|
{
|
2018-06-20 01:52:14 +03:00
|
|
|
// NOTE: Using some SDF generation default values,
|
|
|
|
// trades off precision with ability to handle *smaller* sizes
|
|
|
|
#define SDF_CHAR_PADDING 4
|
|
|
|
#define SDF_ON_EDGE_VALUE 128
|
|
|
|
#define SDF_PIXEL_DIST_SCALE 64.0f
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-09-06 17:56:21 +03:00
|
|
|
#define BITMAP_ALPHA_THRESHOLD 80
|
2018-10-24 14:45:17 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
CharInfo *chars = NULL;
|
2018-10-24 14:45:17 +03:00
|
|
|
|
2019-02-14 13:32:23 +03:00
|
|
|
#if defined(SUPPORT_FILEFORMAT_TTF)
|
2018-06-20 01:52:14 +03:00
|
|
|
// Load font data (including pixel data) from TTF file
|
|
|
|
// NOTE: Loaded information should be enough to generate font image atlas,
|
|
|
|
// using any packaging method
|
|
|
|
FILE *fontFile = fopen(fileName, "rb"); // Load font file
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
if (fontFile != NULL)
|
|
|
|
{
|
|
|
|
fseek(fontFile, 0, SEEK_END);
|
|
|
|
long size = ftell(fontFile); // Get file size
|
|
|
|
fseek(fontFile, 0, SEEK_SET); // Reset file pointer
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
unsigned char *fontBuffer = (unsigned char *)RL_MALLOC(size);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
fread(fontBuffer, size, 1, fontFile);
|
|
|
|
fclose(fontFile);
|
2018-10-24 14:45:17 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
// Init font for data reading
|
|
|
|
stbtt_fontinfo fontInfo;
|
|
|
|
if (!stbtt_InitFont(&fontInfo, fontBuffer, 0)) TraceLog(LOG_WARNING, "Failed to init font!");
|
2017-01-29 01:02:30 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
// Calculate font scale factor
|
|
|
|
float scaleFactor = stbtt_ScaleForPixelHeight(&fontInfo, (float)fontSize);
|
2018-06-20 01:52:14 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
// Calculate font basic metrics
|
|
|
|
// NOTE: ascent is equivalent to font baseline
|
|
|
|
int ascent, descent, lineGap;
|
|
|
|
stbtt_GetFontVMetrics(&fontInfo, &ascent, &descent, &lineGap);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
// In case no chars count provided, default to 95
|
2019-02-22 15:13:11 +03:00
|
|
|
charsCount = (charsCount > 0)? charsCount : 95;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
// Fill fontChars in case not provided externally
|
|
|
|
// NOTE: By default we fill charsCount consecutevely, starting at 32 (Space)
|
|
|
|
int genFontChars = false;
|
2018-10-24 14:45:17 +03:00
|
|
|
if (fontChars == NULL)
|
2018-10-18 18:48:33 +03:00
|
|
|
{
|
2019-04-23 15:55:35 +03:00
|
|
|
fontChars = (int *)RL_MALLOC(charsCount*sizeof(int));
|
2018-10-18 18:48:33 +03:00
|
|
|
for (int i = 0; i < charsCount; i++) fontChars[i] = i + 32;
|
2018-10-24 14:45:17 +03:00
|
|
|
genFontChars = true;
|
2018-10-18 18:48:33 +03:00
|
|
|
}
|
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
chars = (CharInfo *)RL_MALLOC(charsCount*sizeof(CharInfo));
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
// NOTE: Using simple packaging, one char after another
|
2018-11-06 17:10:50 +03:00
|
|
|
for (int i = 0; i < charsCount; i++)
|
2018-09-06 17:56:21 +03:00
|
|
|
{
|
2018-10-18 18:48:33 +03:00
|
|
|
int chw = 0, chh = 0; // Character width and height (on generation)
|
|
|
|
int ch = fontChars[i]; // Character value to get info for
|
|
|
|
chars[i].value = ch;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
// 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 bitmap you provide
|
2018-11-06 17:10:50 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
if (type != FONT_SDF) chars[i].image.data = stbtt_GetCodepointBitmap(&fontInfo, scaleFactor, scaleFactor, ch, &chw, &chh, &chars[i].offsetX, &chars[i].offsetY);
|
|
|
|
else if (ch != 32) chars[i].image.data = stbtt_GetCodepointSDF(&fontInfo, scaleFactor, ch, SDF_CHAR_PADDING, SDF_ON_EDGE_VALUE, SDF_PIXEL_DIST_SCALE, &chw, &chh, &chars[i].offsetX, &chars[i].offsetY);
|
|
|
|
else chars[i].image.data = NULL;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
if (type == FONT_BITMAP)
|
2018-09-06 17:56:21 +03:00
|
|
|
{
|
2018-10-18 18:48:33 +03:00
|
|
|
// 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 < chw*chh; p++)
|
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
if (((unsigned char *)chars[i].image.data)[p] < BITMAP_ALPHA_THRESHOLD) ((unsigned char *)chars[i].image.data)[p] = 0;
|
|
|
|
else ((unsigned char *)chars[i].image.data)[p] = 255;
|
2018-10-18 18:48:33 +03:00
|
|
|
}
|
2018-09-06 17:56:21 +03:00
|
|
|
}
|
2018-11-06 17:10:50 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Load characters images
|
|
|
|
chars[i].image.width = chw;
|
|
|
|
chars[i].image.height = chh;
|
|
|
|
chars[i].image.mipmaps = 1;
|
|
|
|
chars[i].image.format = UNCOMPRESSED_GRAYSCALE;
|
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
chars[i].offsetY += (int)((float)ascent*scaleFactor);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
// Get bounding box for character (may be offset to account for chars that dip above or below the line)
|
|
|
|
int chX1, chY1, chX2, chY2;
|
|
|
|
stbtt_GetCodepointBitmapBox(&fontInfo, ch, scaleFactor, scaleFactor, &chX1, &chY1, &chX2, &chY2);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-18 18:48:33 +03:00
|
|
|
TraceLog(LOG_DEBUG, "Character box measures: %i, %i, %i, %i", chX1, chY1, chX2 - chX1, chY2 - chY1);
|
|
|
|
TraceLog(LOG_DEBUG, "Character offsetY: %i", (int)((float)ascent*scaleFactor) + chY1);
|
|
|
|
|
|
|
|
stbtt_GetCodepointHMetrics(&fontInfo, ch, &chars[i].advanceX, NULL);
|
|
|
|
chars[i].advanceX *= scaleFactor;
|
|
|
|
}
|
2018-10-24 14:45:17 +03:00
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
RL_FREE(fontBuffer);
|
|
|
|
if (genFontChars) RL_FREE(fontChars);
|
2018-06-20 01:52:14 +03:00
|
|
|
}
|
2018-10-18 18:48:33 +03:00
|
|
|
else TraceLog(LOG_WARNING, "[%s] TTF file could not be opened", fileName);
|
2019-02-14 13:32:23 +03:00
|
|
|
#else
|
|
|
|
TraceLog(LOG_WARNING, "[%s] TTF support is disabled", fileName);
|
|
|
|
#endif
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
return chars;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Generate image font atlas using chars info
|
|
|
|
// NOTE: Packing method: 0-Default, 1-Skyline
|
2019-02-14 13:32:23 +03:00
|
|
|
#if defined(SUPPORT_FILEFORMAT_TTF)
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
Image GenImageFontAtlas(const CharInfo *chars, Rectangle **charRecs, int charsCount, int fontSize, int padding, int packMethod)
|
2018-06-20 01:52:14 +03:00
|
|
|
{
|
|
|
|
Image atlas = { 0 };
|
2018-11-06 17:10:50 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
*charRecs = NULL;
|
|
|
|
|
2018-07-15 21:03:05 +03:00
|
|
|
// In case no chars count provided we suppose default of 95
|
2019-08-24 21:03:47 +03:00
|
|
|
charsCount = (charsCount > 0)? charsCount : 95;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// NOTE: Rectangles memory is loaded here!
|
|
|
|
Rectangle *recs = (Rectangle *)RL_MALLOC(charsCount*sizeof(Rectangle));
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-07-15 21:03:05 +03:00
|
|
|
// Calculate image size based on required pixel area
|
|
|
|
// NOTE 1: Image is forced to be squared and POT... very conservative!
|
2018-11-06 17:10:50 +03:00
|
|
|
// NOTE 2: SDF font characters already contain an internal padding,
|
2018-07-15 21:03:05 +03:00
|
|
|
// so image size would result bigger than default font type
|
2018-06-20 01:52:14 +03:00
|
|
|
float requiredArea = 0;
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
for (int i = 0; i < charsCount; i++) requiredArea += ((chars[i].image.width + 2*padding)*(chars[i].image.height + 2*padding));
|
2019-08-24 21:03:47 +03:00
|
|
|
float guessSize = sqrtf(requiredArea)*1.3f;
|
2018-07-15 21:03:05 +03:00
|
|
|
int imageSize = (int)powf(2, ceilf(logf((float)guessSize)/logf(2))); // Calculate next POT
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-07-15 21:03:05 +03:00
|
|
|
atlas.width = imageSize; // Atlas bitmap width
|
|
|
|
atlas.height = imageSize; // Atlas bitmap height
|
2019-04-23 15:55:35 +03:00
|
|
|
atlas.data = (unsigned char *)RL_CALLOC(1, atlas.width*atlas.height); // Create a bitmap to store characters (8 bpp)
|
2018-06-20 01:52:14 +03:00
|
|
|
atlas.format = UNCOMPRESSED_GRAYSCALE;
|
|
|
|
atlas.mipmaps = 1;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-07-15 21:03:05 +03:00
|
|
|
// DEBUG: We can see 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;
|
2018-06-20 01:52:14 +03:00
|
|
|
|
2018-06-21 01:18:13 +03:00
|
|
|
if (packMethod == 0) // Use basic packing algorythm
|
2016-10-27 14:39:47 +03:00
|
|
|
{
|
2018-06-20 01:52:14 +03:00
|
|
|
int offsetX = padding;
|
|
|
|
int offsetY = padding;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
// NOTE: Using simple packaging, one char after another
|
2018-11-06 17:10:50 +03:00
|
|
|
for (int i = 0; i < charsCount; i++)
|
2016-10-31 17:38:15 +03:00
|
|
|
{
|
2018-06-20 01:52:14 +03:00
|
|
|
// Copy pixel data from fc.data to atlas
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
for (int y = 0; y < chars[i].image.height; y++)
|
2018-06-20 01:52:14 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
for (int x = 0; x < chars[i].image.width; x++)
|
2018-06-20 01:52:14 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
((unsigned char *)atlas.data)[(offsetY + y)*atlas.width + (offsetX + x)] = ((unsigned char *)chars[i].image.data)[y*chars[i].image.width + x];
|
2018-06-20 01:52:14 +03:00
|
|
|
}
|
|
|
|
}
|
2018-11-06 17:10:50 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Fill chars rectangles in atlas info
|
|
|
|
recs[i].x = (float)offsetX;
|
|
|
|
recs[i].y = (float)offsetY;
|
|
|
|
recs[i].width = (float)chars[i].image.width;
|
|
|
|
recs[i].height = (float)chars[i].image.height;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
// Move atlas position X for next character drawing
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
offsetX += (chars[i].image.width + 2*padding);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
if (offsetX >= (atlas.width - chars[i].image.width - padding))
|
2018-06-20 01:52:14 +03:00
|
|
|
{
|
|
|
|
offsetX = padding;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
|
|
|
// NOTE: Be careful on offsetY for SDF fonts, by default SDF
|
2018-07-15 21:03:05 +03:00
|
|
|
// use an internal padding of 4 pixels, it means char rectangle
|
|
|
|
// height is bigger than fontSize, it could be up to (fontSize + 8)
|
2018-06-20 01:52:14 +03:00
|
|
|
offsetY += (fontSize + 2*padding);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
if (offsetY > (atlas.height - fontSize - padding)) break;
|
|
|
|
}
|
2016-10-31 17:38:15 +03:00
|
|
|
}
|
2018-06-20 01:52:14 +03:00
|
|
|
}
|
2018-06-21 01:18:13 +03:00
|
|
|
else if (packMethod == 1) // Use Skyline rect packing algorythm (stb_pack_rect)
|
2018-06-20 01:52:14 +03:00
|
|
|
{
|
2018-07-15 21:03:05 +03:00
|
|
|
TraceLog(LOG_DEBUG, "Using Skyline packing algorythm!");
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
stbrp_context *context = (stbrp_context *)RL_MALLOC(sizeof(*context));
|
|
|
|
stbrp_node *nodes = (stbrp_node *)RL_MALLOC(charsCount*sizeof(*nodes));
|
2018-06-20 01:52:14 +03:00
|
|
|
|
|
|
|
stbrp_init_target(context, atlas.width, atlas.height, nodes, charsCount);
|
2019-04-23 15:55:35 +03:00
|
|
|
stbrp_rect *rects = (stbrp_rect *)RL_MALLOC(charsCount*sizeof(stbrp_rect));
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
// Fill rectangles for packaging
|
|
|
|
for (int i = 0; i < charsCount; i++)
|
|
|
|
{
|
|
|
|
rects[i].id = i;
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
rects[i].w = chars[i].image.width + 2*padding;
|
|
|
|
rects[i].h = chars[i].image.height + 2*padding;
|
2018-06-20 01:52:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Package rectangles into atlas
|
|
|
|
stbrp_pack_rects(context, rects, charsCount);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
for (int i = 0; i < charsCount; i++)
|
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// It return char rectangles in atlas
|
|
|
|
recs[i].x = rects[i].x + (float)padding;
|
|
|
|
recs[i].y = rects[i].y + (float)padding;
|
|
|
|
recs[i].width = (float)chars[i].image.width;
|
|
|
|
recs[i].height = (float)chars[i].image.height;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
if (rects[i].was_packed)
|
|
|
|
{
|
|
|
|
// Copy pixel data from fc.data to atlas
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
for (int y = 0; y < chars[i].image.height; y++)
|
2018-06-20 01:52:14 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
for (int x = 0; x < chars[i].image.width; x++)
|
2018-06-20 01:52:14 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
((unsigned char *)atlas.data)[(rects[i].y + padding + y)*atlas.width + (rects[i].x + padding + x)] = ((unsigned char *)chars[i].image.data)[y*chars[i].image.width + x];
|
2018-06-20 01:52:14 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else TraceLog(LOG_WARNING, "Character could not be packed: %i", i);
|
|
|
|
}
|
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
RL_FREE(rects);
|
|
|
|
RL_FREE(nodes);
|
|
|
|
RL_FREE(context);
|
2016-10-27 14:39:47 +03:00
|
|
|
}
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-07-15 21:03:05 +03:00
|
|
|
// TODO: Crop image if required for smaller size
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
// Convert image data from GRAYSCALE to GRAY_ALPHA
|
2018-06-21 01:18:13 +03:00
|
|
|
// WARNING: ImageAlphaMask(&atlas, atlas) does not work in this case, requires manual operation
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
unsigned char *dataGrayAlpha = (unsigned char *)RL_MALLOC(atlas.width*atlas.height*sizeof(unsigned char)*2); // Two channels
|
2016-10-27 14:39:47 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
for (int i = 0, k = 0; i < atlas.width*atlas.height; i++, k += 2)
|
2016-10-27 14:39:47 +03:00
|
|
|
{
|
2018-06-20 01:52:14 +03:00
|
|
|
dataGrayAlpha[k] = 255;
|
|
|
|
dataGrayAlpha[k + 1] = ((unsigned char *)atlas.data)[i];
|
2016-10-27 14:39:47 +03:00
|
|
|
}
|
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
RL_FREE(atlas.data);
|
2018-06-20 01:52:14 +03:00
|
|
|
atlas.data = dataGrayAlpha;
|
|
|
|
atlas.format = UNCOMPRESSED_GRAY_ALPHA;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
*charRecs = recs;
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-06-20 01:52:14 +03:00
|
|
|
return atlas;
|
2016-10-27 14:39:47 +03:00
|
|
|
}
|
2019-02-14 13:32:23 +03:00
|
|
|
#endif
|
2016-10-27 14:39:47 +03:00
|
|
|
|
2018-05-04 17:59:48 +03:00
|
|
|
// Unload Font from GPU memory (VRAM)
|
|
|
|
void UnloadFont(Font font)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
2016-01-02 12:45:51 +03:00
|
|
|
// NOTE: Make sure spriteFont is not default font (fallback)
|
2018-07-05 20:17:06 +03:00
|
|
|
if (font.texture.id != GetFontDefault().texture.id)
|
2016-01-02 12:45:51 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
for (int i = 0; i < font.charsCount; i++) UnloadImage(font.chars[i].image);
|
2019-06-17 00:36:04 +03:00
|
|
|
|
2018-02-18 20:07:57 +03:00
|
|
|
UnloadTexture(font.texture);
|
2019-04-23 15:55:35 +03:00
|
|
|
RL_FREE(font.chars);
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
RL_FREE(font.recs);
|
2016-01-18 14:04:54 +03:00
|
|
|
|
2017-07-02 13:35:13 +03:00
|
|
|
TraceLog(LOG_DEBUG, "Unloaded sprite font data");
|
2016-01-02 12:45:51 +03:00
|
|
|
}
|
2013-11-19 02:38:44 +04:00
|
|
|
}
|
|
|
|
|
2018-10-23 16:43:19 +03:00
|
|
|
// Shows current FPS on top-left corner
|
|
|
|
// NOTE: Uses default font
|
|
|
|
void DrawFPS(int posX, int posY)
|
|
|
|
{
|
|
|
|
// NOTE: We are rendering fps every second for better viewing on high framerates
|
|
|
|
|
|
|
|
static int fps = 0;
|
|
|
|
static int counter = 0;
|
|
|
|
static int refreshRate = 20;
|
|
|
|
|
|
|
|
if (counter < refreshRate) counter++;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fps = GetFPS();
|
|
|
|
refreshRate = fps;
|
|
|
|
counter = 0;
|
|
|
|
}
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2018-10-23 16:43:19 +03:00
|
|
|
// NOTE: We have rounding errors every frame, so it oscillates a lot
|
2018-12-26 15:26:34 +03:00
|
|
|
DrawText(TextFormat("%2i FPS", fps), posX, posY, 20, LIME);
|
2018-10-23 16:43:19 +03:00
|
|
|
}
|
|
|
|
|
2013-11-19 02:38:44 +04:00
|
|
|
// Draw text (using default font)
|
|
|
|
// NOTE: fontSize work like in any drawing program but if fontSize is lower than font-base-size, then font-base-size is used
|
2013-12-19 15:08:06 +04:00
|
|
|
// NOTE: chars spacing is proportional to fontSize
|
2014-09-17 00:51:31 +04:00
|
|
|
void DrawText(const char *text, int posX, int posY, int fontSize, Color color)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
2016-10-09 14:09:08 +03:00
|
|
|
// Check if default font has been loaded
|
2018-07-05 20:17:06 +03:00
|
|
|
if (GetFontDefault().texture.id != 0)
|
2016-10-09 14:09:08 +03:00
|
|
|
{
|
|
|
|
Vector2 position = { (float)posX, (float)posY };
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2016-10-09 14:09:08 +03:00
|
|
|
int defaultFontSize = 10; // Default Font chars height in pixel
|
|
|
|
if (fontSize < defaultFontSize) fontSize = defaultFontSize;
|
|
|
|
int spacing = fontSize/defaultFontSize;
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2018-07-05 20:17:06 +03:00
|
|
|
DrawTextEx(GetFontDefault(), text, position, (float)fontSize, (float)spacing, color);
|
2016-10-09 14:09:08 +03:00
|
|
|
}
|
2013-11-19 02:38:44 +04:00
|
|
|
}
|
|
|
|
|
2018-05-04 17:59:48 +03:00
|
|
|
// Draw text using Font
|
2013-12-19 15:08:06 +04:00
|
|
|
// NOTE: chars spacing is NOT proportional to fontSize
|
2018-05-04 17:59:48 +03:00
|
|
|
void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
2013-11-23 16:30:54 +04:00
|
|
|
int length = strlen(text);
|
2016-11-03 20:57:46 +03:00
|
|
|
int textOffsetY = 0; // Required for line break!
|
2019-05-06 11:17:34 +03:00
|
|
|
float textOffsetX = 0.0f; // Offset between characters
|
2018-10-18 17:00:11 +03:00
|
|
|
float scaleFactor = 0.0f;
|
2017-01-29 01:02:30 +03:00
|
|
|
|
2019-04-21 12:27:46 +03:00
|
|
|
int letter = 0; // Current character
|
2018-10-18 17:00:11 +03:00
|
|
|
int index = 0; // Index position in sprite font
|
2017-01-29 01:02:30 +03:00
|
|
|
|
2018-02-18 20:07:57 +03:00
|
|
|
scaleFactor = fontSize/font.baseSize;
|
2013-11-23 16:30:54 +04:00
|
|
|
|
2016-08-31 11:27:29 +03:00
|
|
|
for (int i = 0; i < length; i++)
|
2015-04-06 15:02:29 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
int next = 0;
|
2019-04-21 12:27:46 +03:00
|
|
|
letter = GetNextCodepoint(&text[i], &next);
|
|
|
|
index = GetGlyphIndex(font, letter);
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// NOTE: Normally we exit the decoding sequence as soon as a bad byte is found (and return 0x3f)
|
|
|
|
// but we need to draw all of the bad bytes using the '?' symbol so to not skip any we set 'next = 1'
|
2019-10-17 18:18:03 +03:00
|
|
|
if (letter == 0x3f) next = 1;
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
i += (next - 1);
|
2019-10-17 18:18:03 +03:00
|
|
|
|
2019-04-21 12:27:46 +03:00
|
|
|
if (letter == '\n')
|
2015-04-06 15:02:29 +03:00
|
|
|
{
|
2016-11-03 20:57:46 +03:00
|
|
|
// NOTE: Fixed line spacing of 1.5 lines
|
2018-02-18 20:07:57 +03:00
|
|
|
textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor);
|
2019-05-06 11:17:34 +03:00
|
|
|
textOffsetX = 0.0f;
|
2015-04-06 15:02:29 +03:00
|
|
|
}
|
2015-10-21 19:24:44 +03:00
|
|
|
else
|
|
|
|
{
|
2019-04-21 12:27:46 +03:00
|
|
|
if (letter != ' ')
|
2018-02-12 13:25:00 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
DrawTexturePro(font.texture, font.recs[index],
|
2018-02-18 20:07:57 +03:00
|
|
|
(Rectangle){ position.x + textOffsetX + font.chars[index].offsetX*scaleFactor,
|
|
|
|
position.y + textOffsetY + font.chars[index].offsetY*scaleFactor,
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
font.recs[index].width*scaleFactor,
|
|
|
|
font.recs[index].height*scaleFactor }, (Vector2){ 0, 0 }, 0.0f, tint);
|
2018-02-12 13:25:00 +03:00
|
|
|
}
|
2015-04-06 15:02:29 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
if (font.chars[index].advanceX == 0) textOffsetX += ((float)font.recs[index].width*scaleFactor + spacing);
|
2019-05-06 11:17:34 +03:00
|
|
|
else textOffsetX += ((float)font.chars[index].advanceX*scaleFactor + spacing);
|
2015-10-21 19:24:44 +03:00
|
|
|
}
|
2015-04-06 15:02:29 +03:00
|
|
|
}
|
2013-11-19 02:38:44 +04:00
|
|
|
}
|
|
|
|
|
2018-12-29 16:44:28 +03:00
|
|
|
// Draw text using font inside rectangle limits
|
2019-02-21 20:45:19 +03:00
|
|
|
void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint)
|
2019-01-23 22:36:54 +03:00
|
|
|
{
|
|
|
|
DrawTextRecEx(font, text, rec, fontSize, spacing, wordWrap, tint, 0, 0, WHITE, WHITE);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Draw text using font inside rectangle limits with support for text selection
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint, int selectStart, int selectLength, Color selectText, Color selectBack)
|
2018-12-29 16:44:28 +03:00
|
|
|
{
|
|
|
|
int length = strlen(text);
|
|
|
|
int textOffsetX = 0; // Offset between characters
|
|
|
|
int textOffsetY = 0; // Required for line break!
|
|
|
|
float scaleFactor = 0.0f;
|
|
|
|
|
2019-04-21 12:27:46 +03:00
|
|
|
int letter = 0; // Current character
|
2018-12-29 16:44:28 +03:00
|
|
|
int index = 0; // Index position in sprite font
|
|
|
|
|
|
|
|
scaleFactor = fontSize/font.baseSize;
|
|
|
|
|
2019-01-23 22:36:54 +03:00
|
|
|
enum { MEASURE_STATE = 0, DRAW_STATE = 1 };
|
2019-02-04 11:57:02 +03:00
|
|
|
int state = wordWrap? MEASURE_STATE : DRAW_STATE;
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
int startLine = -1; // Index where to begin drawing (where a line begins)
|
|
|
|
int endLine = -1; // Index where to stop drawing (where a line ends)
|
|
|
|
int lastk = -1; // Holds last value of the character position
|
2019-10-17 18:18:03 +03:00
|
|
|
|
2019-04-24 22:08:57 +03:00
|
|
|
for (int i = 0, k = 0; i < length; i++, k++)
|
2018-12-29 16:44:28 +03:00
|
|
|
{
|
|
|
|
int glyphWidth = 0;
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
int next = 0;
|
2019-04-21 12:27:46 +03:00
|
|
|
letter = GetNextCodepoint(&text[i], &next);
|
|
|
|
index = GetGlyphIndex(font, letter);
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// NOTE: normally we exit the decoding sequence as soon as a bad byte is found (and return 0x3f)
|
|
|
|
// but we need to draw all of the bad bytes using the '?' symbol so to not skip any we set next = 1
|
2019-10-17 18:18:03 +03:00
|
|
|
if (letter == 0x3f) next = 1;
|
2019-04-21 12:27:46 +03:00
|
|
|
i += next - 1;
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2018-12-29 16:44:28 +03:00
|
|
|
if (letter != '\n')
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
{
|
2019-02-21 20:45:19 +03:00
|
|
|
glyphWidth = (font.chars[index].advanceX == 0)?
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
(int)(font.recs[index].width*scaleFactor + spacing):
|
2019-02-04 11:57:02 +03:00
|
|
|
(int)(font.chars[index].advanceX*scaleFactor + spacing);
|
2018-12-29 16:44:28 +03:00
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// NOTE: When wordWrap is ON we first measure how much of the text we can draw before going outside of the rec container
|
|
|
|
// We store this info in startLine and endLine, then we change states, draw the text between those two variables
|
|
|
|
// and change states again and again recursively until the end of the text (or until we get outside of the container).
|
|
|
|
// When wordWrap is OFF we don't need the measure state so we go to the drawing state immediately
|
|
|
|
// and begin drawing on the next line before we can get outside the container.
|
2019-02-21 20:45:19 +03:00
|
|
|
if (state == MEASURE_STATE)
|
2018-12-29 16:44:28 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// TODO: there are multiple types of spaces in UNICODE, maybe it's a good idea to add support for more
|
2019-10-17 18:18:03 +03:00
|
|
|
// See: http://jkorpela.fi/chars/spaces.html
|
2019-02-04 11:57:02 +03:00
|
|
|
if ((letter == ' ') || (letter == '\t') || (letter == '\n')) endLine = i;
|
2019-02-21 20:45:19 +03:00
|
|
|
|
|
|
|
if ((textOffsetX + glyphWidth + 1) >= rec.width)
|
2018-12-29 16:44:28 +03:00
|
|
|
{
|
2019-02-22 15:13:11 +03:00
|
|
|
endLine = (endLine < 1)? i : endLine;
|
2019-04-21 12:27:46 +03:00
|
|
|
if (i == endLine) endLine -= next;
|
|
|
|
if ((startLine + next) == endLine) endLine = i - next;
|
2019-01-23 22:36:54 +03:00
|
|
|
state = !state;
|
2019-02-21 20:45:19 +03:00
|
|
|
}
|
|
|
|
else if ((i + 1) == length)
|
2019-01-23 22:36:54 +03:00
|
|
|
{
|
|
|
|
endLine = i;
|
|
|
|
state = !state;
|
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
else if (letter == '\n')
|
2019-01-23 22:36:54 +03:00
|
|
|
{
|
|
|
|
state = !state;
|
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2019-02-04 11:57:02 +03:00
|
|
|
if (state == DRAW_STATE)
|
|
|
|
{
|
2019-01-23 22:36:54 +03:00
|
|
|
textOffsetX = 0;
|
|
|
|
i = startLine;
|
2018-12-29 16:44:28 +03:00
|
|
|
glyphWidth = 0;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
2019-05-10 13:57:24 +03:00
|
|
|
// Save character position when we switch states
|
|
|
|
int tmp = lastk;
|
|
|
|
lastk = k - 1;
|
|
|
|
k = tmp;
|
2018-12-29 16:44:28 +03:00
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
}
|
|
|
|
else
|
2018-12-29 16:44:28 +03:00
|
|
|
{
|
2019-01-23 22:36:54 +03:00
|
|
|
if (letter == '\n')
|
2018-12-29 16:44:28 +03:00
|
|
|
{
|
2019-02-04 11:57:02 +03:00
|
|
|
if (!wordWrap)
|
|
|
|
{
|
2019-01-23 22:36:54 +03:00
|
|
|
textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor);
|
|
|
|
textOffsetX = 0;
|
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
}
|
|
|
|
else
|
2018-12-29 16:44:28 +03:00
|
|
|
{
|
2019-02-04 11:57:02 +03:00
|
|
|
if (!wordWrap && ((textOffsetX + glyphWidth + 1) >= rec.width))
|
|
|
|
{
|
2018-12-29 16:44:28 +03:00
|
|
|
textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor);
|
|
|
|
textOffsetX = 0;
|
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2019-02-22 13:27:20 +03:00
|
|
|
if ((textOffsetY + (int)(font.baseSize*scaleFactor)) > rec.height) break;
|
2019-02-21 20:45:19 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Draw selected
|
2019-01-23 22:36:54 +03:00
|
|
|
bool isGlyphSelected = false;
|
2019-04-24 22:08:57 +03:00
|
|
|
if ((selectStart >= 0) && (k >= selectStart) && (k < (selectStart + selectLength)))
|
2019-02-04 11:57:02 +03:00
|
|
|
{
|
2019-05-10 13:57:24 +03:00
|
|
|
Rectangle strec = {rec.x + textOffsetX-1, rec.y + textOffsetY, glyphWidth, font.baseSize*scaleFactor };
|
2019-02-04 11:57:02 +03:00
|
|
|
DrawRectangleRec(strec, selectBack);
|
2019-01-23 22:36:54 +03:00
|
|
|
isGlyphSelected = true;
|
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Draw glyph
|
2019-01-23 22:36:54 +03:00
|
|
|
if ((letter != ' ') && (letter != '\t'))
|
2018-12-29 16:44:28 +03:00
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
DrawTexturePro(font.texture, font.recs[index],
|
2019-01-23 22:36:54 +03:00
|
|
|
(Rectangle){ rec.x + textOffsetX + font.chars[index].offsetX*scaleFactor,
|
|
|
|
rec.y + textOffsetY + font.chars[index].offsetY*scaleFactor,
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
font.recs[index].width*scaleFactor,
|
|
|
|
font.recs[index].height*scaleFactor }, (Vector2){ 0, 0 }, 0.0f,
|
2019-02-22 15:13:11 +03:00
|
|
|
(!isGlyphSelected)? tint : selectText);
|
2018-12-29 16:44:28 +03:00
|
|
|
}
|
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
|
|
|
|
if (wordWrap && (i == endLine))
|
2019-01-23 22:36:54 +03:00
|
|
|
{
|
|
|
|
textOffsetY += (int)((font.baseSize + font.baseSize/2)*scaleFactor);
|
|
|
|
textOffsetX = 0;
|
|
|
|
startLine = endLine;
|
|
|
|
endLine = -1;
|
|
|
|
glyphWidth = 0;
|
2019-05-10 13:57:24 +03:00
|
|
|
k = lastk;
|
2019-01-23 22:36:54 +03:00
|
|
|
state = !state;
|
|
|
|
}
|
2018-12-29 16:44:28 +03:00
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2018-12-29 16:44:28 +03:00
|
|
|
textOffsetX += glyphWidth;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-19 02:38:44 +04:00
|
|
|
// Measure string width for default font
|
2013-11-28 22:59:56 +04:00
|
|
|
int MeasureText(const char *text, int fontSize)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
2016-10-09 14:09:08 +03:00
|
|
|
Vector2 vec = { 0.0f, 0.0f };
|
2013-11-19 02:38:44 +04:00
|
|
|
|
2016-10-09 14:09:08 +03:00
|
|
|
// Check if default font has been loaded
|
2018-07-05 20:17:06 +03:00
|
|
|
if (GetFontDefault().texture.id != 0)
|
2016-10-09 14:09:08 +03:00
|
|
|
{
|
|
|
|
int defaultFontSize = 10; // Default Font chars height in pixel
|
|
|
|
if (fontSize < defaultFontSize) fontSize = defaultFontSize;
|
|
|
|
int spacing = fontSize/defaultFontSize;
|
2014-10-17 23:11:58 +04:00
|
|
|
|
2018-07-05 20:17:06 +03:00
|
|
|
vec = MeasureTextEx(GetFontDefault(), text, (float)fontSize, (float)spacing);
|
2016-10-09 14:09:08 +03:00
|
|
|
}
|
2013-11-19 02:38:44 +04:00
|
|
|
|
2013-11-23 16:30:54 +04:00
|
|
|
return (int)vec.x;
|
2013-11-19 02:38:44 +04:00
|
|
|
}
|
|
|
|
|
2018-05-04 17:59:48 +03:00
|
|
|
// Measure string size for Font
|
|
|
|
Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
2013-11-23 16:30:54 +04:00
|
|
|
int len = strlen(text);
|
2016-12-25 04:01:13 +03:00
|
|
|
int tempLen = 0; // Used to count longer text line num chars
|
2015-12-09 22:57:50 +03:00
|
|
|
int lenCounter = 0;
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2018-10-18 17:00:11 +03:00
|
|
|
float textWidth = 0.0f;
|
|
|
|
float tempTextWidth = 0.0f; // Used to count longer text line width
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2018-02-18 20:07:57 +03:00
|
|
|
float textHeight = (float)font.baseSize;
|
|
|
|
float scaleFactor = fontSize/(float)font.baseSize;
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2019-04-21 12:27:46 +03:00
|
|
|
int letter = 0; // Current character
|
2019-01-05 17:04:18 +03:00
|
|
|
int index = 0; // Index position in sprite font
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2013-11-23 16:30:54 +04:00
|
|
|
for (int i = 0; i < len; i++)
|
|
|
|
{
|
2015-12-09 22:57:50 +03:00
|
|
|
lenCounter++;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
int next = 0;
|
2019-04-21 12:27:46 +03:00
|
|
|
letter = GetNextCodepoint(&text[i], &next);
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
index = GetGlyphIndex(font, letter);
|
2019-05-06 11:17:34 +03:00
|
|
|
|
2019-04-21 12:27:46 +03:00
|
|
|
// NOTE: normally we exit the decoding sequence as soon as a bad byte is found (and return 0x3f)
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// but we need to draw all of the bad bytes using the '?' symbol so to not skip any we set next = 1
|
2019-10-17 18:18:03 +03:00
|
|
|
if (letter == 0x3f) next = 1;
|
|
|
|
i += next - 1;
|
|
|
|
|
2019-04-21 12:27:46 +03:00
|
|
|
if (letter != '\n')
|
2015-12-09 22:57:50 +03:00
|
|
|
{
|
2018-02-18 20:07:57 +03:00
|
|
|
if (font.chars[index].advanceX != 0) textWidth += font.chars[index].advanceX;
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
else textWidth += (font.recs[index].width + font.chars[index].offsetX);
|
2015-12-09 22:57:50 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (tempTextWidth < textWidth) tempTextWidth = textWidth;
|
|
|
|
lenCounter = 0;
|
|
|
|
textWidth = 0;
|
2018-02-18 20:07:57 +03:00
|
|
|
textHeight += ((float)font.baseSize*1.5f); // NOTE: Fixed line spacing of 1.5 lines
|
2015-12-09 22:57:50 +03:00
|
|
|
}
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2015-12-09 22:57:50 +03:00
|
|
|
if (tempLen < lenCounter) tempLen = lenCounter;
|
2013-11-23 16:30:54 +04:00
|
|
|
}
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2015-12-09 22:57:50 +03:00
|
|
|
if (tempTextWidth < textWidth) tempTextWidth = textWidth;
|
2014-09-03 18:51:28 +04:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
Vector2 vec = { 0 };
|
2016-12-05 03:14:18 +03:00
|
|
|
vec.x = tempTextWidth*scaleFactor + (float)((tempLen - 1)*spacing); // Adds chars spacing to measure
|
|
|
|
vec.y = textHeight*scaleFactor;
|
2014-09-03 18:51:28 +04:00
|
|
|
|
2013-11-23 16:30:54 +04:00
|
|
|
return vec;
|
2013-11-19 02:38:44 +04:00
|
|
|
}
|
|
|
|
|
2018-02-18 20:07:57 +03:00
|
|
|
// Returns index position for a unicode character on spritefont
|
2018-05-04 17:59:48 +03:00
|
|
|
int GetGlyphIndex(Font font, int character)
|
2018-02-18 20:07:57 +03:00
|
|
|
{
|
|
|
|
#define UNORDERED_CHARSET
|
|
|
|
#if defined(UNORDERED_CHARSET)
|
|
|
|
int index = 0;
|
|
|
|
|
|
|
|
for (int i = 0; i < font.charsCount; i++)
|
|
|
|
{
|
|
|
|
if (font.chars[i].value == character)
|
|
|
|
{
|
|
|
|
index = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return index;
|
|
|
|
#else
|
|
|
|
return (character - 32);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2018-12-26 15:26:34 +03:00
|
|
|
// Text strings management functions
|
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Check if two text string are equal
|
|
|
|
// REQUIRES: strcmp()
|
|
|
|
bool TextIsEqual(const char *text1, const char *text2)
|
|
|
|
{
|
|
|
|
bool result = false;
|
|
|
|
|
|
|
|
if (strcmp(text1, text2) == 0) result = true;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get text length in bytes, check for \0 character
|
|
|
|
unsigned int TextLength(const char *text)
|
|
|
|
{
|
|
|
|
unsigned int length = 0;
|
|
|
|
|
|
|
|
while (*text++) length++;
|
|
|
|
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
2018-10-23 16:43:19 +03:00
|
|
|
// Formatting of text with variables to 'embed'
|
2019-11-24 16:08:27 +03:00
|
|
|
// WARNING: String returned will expire after this function is called MAX_TEXTFORMAT_BUFFERS times
|
2018-12-26 15:26:34 +03:00
|
|
|
const char *TextFormat(const char *text, ...)
|
2013-11-19 02:38:44 +04:00
|
|
|
{
|
2019-11-24 16:08:27 +03:00
|
|
|
#define MAX_TEXTFORMAT_BUFFERS 4
|
|
|
|
|
|
|
|
// We create an array of buffers so strings don't expire until MAX_TEXTFORMAT_BUFFERS invocations
|
|
|
|
static char buffers[MAX_TEXTFORMAT_BUFFERS][MAX_TEXT_BUFFER_LENGTH] = { 0 };
|
2019-11-24 16:01:35 +03:00
|
|
|
static int index = 0;
|
2019-11-24 16:08:27 +03:00
|
|
|
|
|
|
|
char *currentBuffer = buffers[index];
|
2017-03-05 21:17:00 +03:00
|
|
|
|
2018-10-23 16:43:19 +03:00
|
|
|
va_list args;
|
|
|
|
va_start(args, text);
|
2019-11-24 16:08:27 +03:00
|
|
|
vsprintf(currentBuffer, text, args);
|
2018-10-23 16:43:19 +03:00
|
|
|
va_end(args);
|
2019-11-24 16:08:27 +03:00
|
|
|
|
|
|
|
index += 1; // Move to next buffer for next function call
|
|
|
|
if (index >= MAX_TEXTFORMAT_BUFFERS) index = 0;
|
2017-03-05 21:17:00 +03:00
|
|
|
|
2019-11-24 16:08:27 +03:00
|
|
|
return currentBuffer;
|
2018-10-23 16:43:19 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Get a piece of a text string
|
2018-12-26 15:26:34 +03:00
|
|
|
// REQUIRES: strlen()
|
|
|
|
const char *TextSubtext(const char *text, int position, int length)
|
2018-10-23 16:43:19 +03:00
|
|
|
{
|
2018-12-26 15:26:34 +03:00
|
|
|
static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
|
|
|
|
|
2018-10-23 16:43:19 +03:00
|
|
|
int textLength = strlen(text);
|
|
|
|
|
|
|
|
if (position >= textLength)
|
2017-03-05 21:17:00 +03:00
|
|
|
{
|
2018-10-23 16:43:19 +03:00
|
|
|
position = textLength - 1;
|
|
|
|
length = 0;
|
2017-03-05 21:17:00 +03:00
|
|
|
}
|
2018-10-23 16:43:19 +03:00
|
|
|
|
|
|
|
if (length >= textLength) length = textLength;
|
|
|
|
|
|
|
|
for (int c = 0 ; c < length ; c++)
|
|
|
|
{
|
|
|
|
*(buffer + c) = *(text + position);
|
|
|
|
text++;
|
|
|
|
}
|
|
|
|
|
|
|
|
*(buffer + length) = '\0';
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2018-12-26 15:26:34 +03:00
|
|
|
// Replace text string
|
|
|
|
// REQUIRES: strlen(), strstr(), strncpy(), strcpy()
|
|
|
|
// WARNING: Internally allocated memory must be freed by the user (if return != NULL)
|
2019-07-22 22:29:50 +03:00
|
|
|
char *TextReplace(char *text, const char *replace, const char *by)
|
2018-12-26 15:26:34 +03:00
|
|
|
{
|
|
|
|
char *result;
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2018-12-26 15:26:34 +03:00
|
|
|
char *insertPoint; // Next insert point
|
|
|
|
char *temp; // Temp pointer
|
|
|
|
int replaceLen; // Replace string length of (the string to remove)
|
|
|
|
int byLen; // Replacement length (the string to replace replace by)
|
|
|
|
int lastReplacePos; // Distance between replace and end of last replace
|
|
|
|
int count; // Number of replacements
|
|
|
|
|
|
|
|
// Sanity checks and initialization
|
|
|
|
if (!text || !replace) return NULL;
|
|
|
|
|
|
|
|
replaceLen = strlen(replace);
|
|
|
|
if (replaceLen == 0) return NULL; // Empty replace causes infinite loop during count
|
|
|
|
|
|
|
|
if (!by) by = ""; // Replace by nothing if not provided
|
|
|
|
byLen = strlen(by);
|
|
|
|
|
|
|
|
// Count the number of replacements needed
|
|
|
|
insertPoint = text;
|
|
|
|
for (count = 0; (temp = strstr(insertPoint, replace)); count++) insertPoint = temp + replaceLen;
|
|
|
|
|
|
|
|
// Allocate returning string and point temp to it
|
2019-04-23 15:55:35 +03:00
|
|
|
temp = result = RL_MALLOC(strlen(text) + (byLen - replaceLen)*count + 1);
|
2018-12-26 15:26:34 +03:00
|
|
|
|
|
|
|
if (!result) return NULL; // Memory could not be allocated
|
|
|
|
|
|
|
|
// First time through the loop, all the variable are set correctly from here on,
|
|
|
|
// temp points to the end of the result string
|
|
|
|
// insertPoint points to the next occurrence of replace in text
|
|
|
|
// text points to the remainder of text after "end of replace"
|
|
|
|
while (count--)
|
|
|
|
{
|
|
|
|
insertPoint = strstr(text, replace);
|
|
|
|
lastReplacePos = insertPoint - text;
|
|
|
|
temp = strncpy(temp, text, lastReplacePos) + lastReplacePos;
|
|
|
|
temp = strcpy(temp, by) + byLen;
|
|
|
|
text += lastReplacePos + replaceLen; // Move to next "end of replace"
|
|
|
|
}
|
|
|
|
|
|
|
|
// Copy remaind text part after replacement to result (pointed by moving temp)
|
|
|
|
strcpy(temp, text);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert text in a specific position, moves all text forward
|
|
|
|
// REQUIRES: strlen(), strcpy(), strtok()
|
|
|
|
// WARNING: Allocated memory should be manually freed
|
2019-07-22 22:29:50 +03:00
|
|
|
char *TextInsert(const char *text, const char *insert, int position)
|
2018-12-26 15:26:34 +03:00
|
|
|
{
|
|
|
|
int textLen = strlen(text);
|
|
|
|
int insertLen = strlen(insert);
|
|
|
|
|
2019-04-23 15:55:35 +03:00
|
|
|
char *result = (char *)RL_MALLOC(textLen + insertLen + 1);
|
2018-12-26 15:26:34 +03:00
|
|
|
|
|
|
|
for (int i = 0; i < position; i++) result[i] = text[i];
|
|
|
|
for (int i = position; i < insertLen + position; i++) result[i] = insert[i];
|
|
|
|
for (int i = (insertLen + position); i < (textLen + insertLen); i++) result[i] = text[i];
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2018-12-26 15:26:34 +03:00
|
|
|
result[textLen + insertLen] = '\0'; // Make sure text string is valid!
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Join text strings with delimiter
|
|
|
|
// REQUIRES: strcat()
|
|
|
|
const char *TextJoin(const char **textList, int count, const char *delimiter)
|
|
|
|
{
|
|
|
|
static char text[MAX_TEXT_BUFFER_LENGTH] = { 0 };
|
|
|
|
memset(text, 0, MAX_TEXT_BUFFER_LENGTH);
|
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
int totalLength = 0;
|
2018-12-26 15:26:34 +03:00
|
|
|
int delimiterLen = strlen(delimiter);
|
|
|
|
|
|
|
|
for (int i = 0; i < count; i++)
|
|
|
|
{
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
int textListLength = strlen(textList[i]);
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Make sure joined text could fit inside MAX_TEXT_BUFFER_LENGTH
|
|
|
|
if ((totalLength + textListLength) < MAX_TEXT_BUFFER_LENGTH)
|
|
|
|
{
|
|
|
|
strcat(text, textList[i]);
|
|
|
|
totalLength += textListLength;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
|
|
|
if ((delimiterLen > 0) && (i < (count - 1)))
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
{
|
|
|
|
strcat(text, delimiter);
|
|
|
|
totalLength += delimiterLen;
|
|
|
|
}
|
|
|
|
}
|
2018-12-26 15:26:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return text;
|
|
|
|
}
|
|
|
|
|
2018-10-23 16:43:19 +03:00
|
|
|
// Split string into multiple strings
|
2019-02-11 20:02:32 +03:00
|
|
|
const char **TextSplit(const char *text, char delimiter, int *count)
|
2018-10-23 16:43:19 +03:00
|
|
|
{
|
2019-02-11 20:02:32 +03:00
|
|
|
// NOTE: Current implementation returns a copy of the provided string with '\0' (string end delimiter)
|
|
|
|
// inserted between strings defined by "delimiter" parameter. No memory is dynamically allocated,
|
|
|
|
// all used memory is static... it has some limitations:
|
2019-10-22 01:37:10 +03:00
|
|
|
// 1. Maximum number of possible split strings is set by TEXTSPLIT_MAX_SUBSTRINGS_COUNT
|
|
|
|
// 2. Maximum size of text to split is TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2019-10-22 01:37:10 +03:00
|
|
|
static const char *result[TEXTSPLIT_MAX_SUBSTRINGS_COUNT] = { NULL };
|
|
|
|
static char buffer[TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH] = { 0 };
|
|
|
|
memset(buffer, 0, TEXTSPLIT_MAX_TEXT_BUFFER_LENGTH);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
2019-02-11 20:02:32 +03:00
|
|
|
result[0] = buffer;
|
2019-08-19 16:09:54 +03:00
|
|
|
int counter = 0;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
2019-08-19 16:09:54 +03:00
|
|
|
if (text != NULL)
|
2018-12-26 15:26:34 +03:00
|
|
|
{
|
2019-08-19 16:09:54 +03:00
|
|
|
counter = 1;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
2019-08-19 16:09:54 +03:00
|
|
|
// Count how many substrings we have on text and point to every one
|
|
|
|
for (int i = 0; i < MAX_TEXT_BUFFER_LENGTH; i++)
|
2018-12-26 15:26:34 +03:00
|
|
|
{
|
2019-08-19 16:09:54 +03:00
|
|
|
buffer[i] = text[i];
|
|
|
|
if (buffer[i] == '\0') break;
|
|
|
|
else if (buffer[i] == delimiter)
|
|
|
|
{
|
|
|
|
buffer[i] = '\0'; // Set an end of string at this point
|
|
|
|
result[counter] = buffer + i + 1;
|
|
|
|
counter++;
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2019-10-22 01:37:10 +03:00
|
|
|
if (counter == TEXTSPLIT_MAX_SUBSTRINGS_COUNT) break;
|
2019-08-19 16:09:54 +03:00
|
|
|
}
|
2018-12-26 15:26:34 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-11 20:02:32 +03:00
|
|
|
*count = counter;
|
|
|
|
return result;
|
2018-12-26 15:26:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Append text at specific position and move cursor!
|
|
|
|
// REQUIRES: strcpy()
|
|
|
|
void TextAppend(char *text, const char *append, int *position)
|
|
|
|
{
|
|
|
|
strcpy(text + *position, append);
|
|
|
|
*position += strlen(append);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find first text occurrence within a string
|
|
|
|
// REQUIRES: strstr()
|
|
|
|
int TextFindIndex(const char *text, const char *find)
|
|
|
|
{
|
|
|
|
int position = -1;
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2018-12-26 15:26:34 +03:00
|
|
|
char *ptr = strstr(text, find);
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2018-12-26 15:26:34 +03:00
|
|
|
if (ptr != NULL) position = ptr - text;
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2018-12-26 15:26:34 +03:00
|
|
|
return position;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get upper case version of provided string
|
|
|
|
// REQUIRES: toupper()
|
|
|
|
const char *TextToUpper(const char *text)
|
|
|
|
{
|
|
|
|
static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
|
|
|
|
|
|
|
|
for (int i = 0; i < MAX_TEXT_BUFFER_LENGTH; i++)
|
|
|
|
{
|
|
|
|
if (text[i] != '\0') buffer[i] = (char)toupper(text[i]);
|
|
|
|
else { buffer[i] = '\0'; break; }
|
|
|
|
}
|
|
|
|
|
|
|
|
return buffer;
|
2018-10-29 18:18:06 +03:00
|
|
|
}
|
|
|
|
|
2018-12-26 15:26:34 +03:00
|
|
|
// Get lower case version of provided string
|
|
|
|
// REQUIRES: tolower()
|
|
|
|
const char *TextToLower(const char *text)
|
|
|
|
{
|
|
|
|
static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
|
|
|
|
|
|
|
|
for (int i = 0; i < MAX_TEXT_BUFFER_LENGTH; i++)
|
|
|
|
{
|
|
|
|
if (text[i] != '\0') buffer[i] = (char)tolower(text[i]);
|
|
|
|
else { buffer[i] = '\0'; break; }
|
|
|
|
}
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get Pascal case notation version of provided string
|
|
|
|
// REQUIRES: toupper()
|
|
|
|
const char *TextToPascal(const char *text)
|
|
|
|
{
|
|
|
|
static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
|
|
|
|
|
|
|
|
buffer[0] = (char)toupper(text[0]);
|
|
|
|
|
|
|
|
for (int i = 1, j = 1; i < MAX_TEXT_BUFFER_LENGTH; i++, j++)
|
|
|
|
{
|
|
|
|
if (text[j] != '\0')
|
|
|
|
{
|
|
|
|
if (text[j] != '_') buffer[i] = text[j];
|
|
|
|
else
|
|
|
|
{
|
|
|
|
j++;
|
|
|
|
buffer[i] = (char)toupper(text[j]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else { buffer[i] = '\0'; break; }
|
|
|
|
}
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
2019-02-06 16:20:14 +03:00
|
|
|
|
|
|
|
// Get integer value from text
|
|
|
|
// NOTE: Negative values not supported
|
|
|
|
int TextToInteger(const char *text)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
int len = strlen(text);
|
|
|
|
int units = 1;
|
|
|
|
|
|
|
|
for (int i = len - 1; i >= 0; i--)
|
|
|
|
{
|
|
|
|
if ((text[i] > 47) && (text[i] < 58)) result += ((int)text[i] - 48)*units;
|
|
|
|
else { result = -1; break; }
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2019-02-06 16:20:14 +03:00
|
|
|
units *= 10;
|
|
|
|
}
|
2019-02-21 20:45:19 +03:00
|
|
|
|
2019-02-06 16:20:14 +03:00
|
|
|
return result;
|
|
|
|
}
|
2019-10-28 01:56:48 +03:00
|
|
|
|
2019-10-28 22:53:32 +03:00
|
|
|
// Encode text codepoint into utf8 text (memory must be freed!)
|
|
|
|
char *TextToUtf8(int *codepoints, int length)
|
2019-10-28 01:56:48 +03:00
|
|
|
{
|
2019-10-28 22:53:32 +03:00
|
|
|
// We allocate enough memory fo fit all possible codepoints
|
|
|
|
// NOTE: 5 bytes for every codepoint should be enough
|
|
|
|
char *text = (char *)calloc(length*5, 1);
|
|
|
|
const char *utf8 = NULL;
|
|
|
|
int size = 0;
|
|
|
|
|
|
|
|
for (int i = 0, bytes = 0; i < length; i++)
|
2019-10-28 01:56:48 +03:00
|
|
|
{
|
2019-10-28 22:53:32 +03:00
|
|
|
utf8 = CodepointToUtf8(codepoints[i], &bytes);
|
|
|
|
strncpy(text + size, utf8, bytes);
|
|
|
|
size += bytes;
|
2019-10-28 01:56:48 +03:00
|
|
|
}
|
2019-10-28 22:53:32 +03:00
|
|
|
|
|
|
|
// Resize memory to text length + string NULL terminator
|
2019-10-29 17:57:19 +03:00
|
|
|
text = realloc(text, size + 1);
|
2019-10-28 22:53:32 +03:00
|
|
|
|
|
|
|
return text;
|
2019-10-28 01:56:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Get all codepoints in a string, codepoints count returned by parameters
|
|
|
|
int *GetCodepoints(const char *text, int *count)
|
|
|
|
{
|
|
|
|
static int codepoints[MAX_TEXT_UNICODE_CHARS] = { 0 };
|
|
|
|
memset(codepoints, 0, MAX_TEXT_UNICODE_CHARS*sizeof(int));
|
|
|
|
|
|
|
|
int bytesProcessed = 0;
|
|
|
|
int textLength = strlen(text);
|
|
|
|
int codepointsCount = 0;
|
|
|
|
|
|
|
|
for (int i = 0; i < textLength; codepointsCount++)
|
|
|
|
{
|
|
|
|
codepoints[codepointsCount] = GetNextCodepoint(text + i, &bytesProcessed);
|
|
|
|
i += bytesProcessed;
|
|
|
|
}
|
|
|
|
|
|
|
|
*count = codepointsCount;
|
|
|
|
|
|
|
|
return codepoints;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns total number of characters(codepoints) in a UTF8 encoded text, until '\0' is found
|
|
|
|
// NOTE: If an invalid UTF8 sequence is encountered a '?'(0x3f) codepoint is counted instead
|
|
|
|
int GetCodepointsCount(const char *text)
|
|
|
|
{
|
|
|
|
unsigned int len = 0;
|
|
|
|
char *ptr = (char *)&text[0];
|
|
|
|
|
|
|
|
while (*ptr != '\0')
|
|
|
|
{
|
|
|
|
int next = 0;
|
|
|
|
int letter = GetNextCodepoint(ptr, &next);
|
|
|
|
|
|
|
|
if (letter == 0x3f) ptr += 1;
|
|
|
|
else ptr += next;
|
|
|
|
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Returns next codepoint in a UTF8 encoded text, scanning until '\0' is found
|
|
|
|
// When a invalid UTF8 byte is encountered we exit as soon as possible and a '?'(0x3f) codepoint is returned
|
|
|
|
// Total number of bytes processed are returned as a parameter
|
|
|
|
// NOTE: the standard says U+FFFD should be returned in case of errors
|
|
|
|
// but that character is not supported by the default font in raylib
|
|
|
|
// TODO: optimize this code for speed!!
|
|
|
|
int GetNextCodepoint(const char *text, int *bytesProcessed)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
UTF8 specs from https://www.ietf.org/rfc/rfc3629.txt
|
|
|
|
|
|
|
|
Char. number range | UTF-8 octet sequence
|
|
|
|
(hexadecimal) | (binary)
|
|
|
|
--------------------+---------------------------------------------
|
|
|
|
0000 0000-0000 007F | 0xxxxxxx
|
|
|
|
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
|
|
|
|
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
|
|
|
|
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
|
|
*/
|
|
|
|
// NOTE: on decode errors we return as soon as possible
|
|
|
|
|
|
|
|
int code = 0x3f; // Codepoint (defaults to '?')
|
|
|
|
int octet = (unsigned char)(text[0]); // The first UTF8 octet
|
|
|
|
*bytesProcessed = 1;
|
|
|
|
|
|
|
|
if (octet <= 0x7f)
|
|
|
|
{
|
|
|
|
// Only one octet (ASCII range x00-7F)
|
|
|
|
code = text[0];
|
|
|
|
}
|
|
|
|
else if ((octet & 0xe0) == 0xc0)
|
|
|
|
{
|
|
|
|
// Two octets
|
|
|
|
// [0]xC2-DF [1]UTF8-tail(x80-BF)
|
|
|
|
unsigned char octet1 = text[1];
|
|
|
|
|
|
|
|
if ((octet1 == '\0') || ((octet1 >> 6) != 2)) { *bytesProcessed = 2; return code; } // Unexpected sequence
|
|
|
|
|
|
|
|
if ((octet >= 0xc2) && (octet <= 0xdf))
|
|
|
|
{
|
|
|
|
code = ((octet & 0x1f) << 6) | (octet1 & 0x3f);
|
|
|
|
*bytesProcessed = 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((octet & 0xf0) == 0xe0)
|
|
|
|
{
|
|
|
|
// Three octets
|
|
|
|
unsigned char octet1 = text[1];
|
|
|
|
unsigned char octet2 = '\0';
|
|
|
|
|
|
|
|
if ((octet1 == '\0') || ((octet1 >> 6) != 2)) { *bytesProcessed = 2; return code; } // Unexpected sequence
|
|
|
|
|
|
|
|
octet2 = text[2];
|
|
|
|
|
|
|
|
if ((octet2 == '\0') || ((octet2 >> 6) != 2)) { *bytesProcessed = 3; return code; } // Unexpected sequence
|
|
|
|
|
|
|
|
/*
|
|
|
|
[0]xE0 [1]xA0-BF [2]UTF8-tail(x80-BF)
|
|
|
|
[0]xE1-EC [1]UTF8-tail [2]UTF8-tail(x80-BF)
|
|
|
|
[0]xED [1]x80-9F [2]UTF8-tail(x80-BF)
|
|
|
|
[0]xEE-EF [1]UTF8-tail [2]UTF8-tail(x80-BF)
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (((octet == 0xe0) && !((octet1 >= 0xa0) && (octet1 <= 0xbf))) ||
|
|
|
|
((octet == 0xed) && !((octet1 >= 0x80) && (octet1 <= 0x9f)))) { *bytesProcessed = 2; return code; }
|
|
|
|
|
|
|
|
if ((octet >= 0xe0) && (0 <= 0xef))
|
|
|
|
{
|
|
|
|
code = ((octet & 0xf) << 12) | ((octet1 & 0x3f) << 6) | (octet2 & 0x3f);
|
|
|
|
*bytesProcessed = 3;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((octet & 0xf8) == 0xf0)
|
|
|
|
{
|
|
|
|
// Four octets
|
|
|
|
if (octet > 0xf4) return code;
|
|
|
|
|
|
|
|
unsigned char octet1 = text[1];
|
|
|
|
unsigned char octet2 = '\0';
|
|
|
|
unsigned char octet3 = '\0';
|
|
|
|
|
|
|
|
if ((octet1 == '\0') || ((octet1 >> 6) != 2)) { *bytesProcessed = 2; return code; } // Unexpected sequence
|
|
|
|
|
|
|
|
octet2 = text[2];
|
|
|
|
|
|
|
|
if ((octet2 == '\0') || ((octet2 >> 6) != 2)) { *bytesProcessed = 3; return code; } // Unexpected sequence
|
|
|
|
|
|
|
|
octet3 = text[3];
|
|
|
|
|
|
|
|
if ((octet3 == '\0') || ((octet3 >> 6) != 2)) { *bytesProcessed = 4; return code; } // Unexpected sequence
|
|
|
|
|
|
|
|
/*
|
|
|
|
[0]xF0 [1]x90-BF [2]UTF8-tail [3]UTF8-tail
|
|
|
|
[0]xF1-F3 [1]UTF8-tail [2]UTF8-tail [3]UTF8-tail
|
|
|
|
[0]xF4 [1]x80-8F [2]UTF8-tail [3]UTF8-tail
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (((octet == 0xf0) && !((octet1 >= 0x90) && (octet1 <= 0xbf))) ||
|
|
|
|
((octet == 0xf4) && !((octet1 >= 0x80) && (octet1 <= 0x8f)))) { *bytesProcessed = 2; return code; } // Unexpected sequence
|
|
|
|
|
|
|
|
if (octet >= 0xf0)
|
|
|
|
{
|
|
|
|
code = ((octet & 0x7) << 18) | ((octet1 & 0x3f) << 12) | ((octet2 & 0x3f) << 6) | (octet3 & 0x3f);
|
|
|
|
*bytesProcessed = 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (code > 0x10ffff) code = 0x3f; // Codepoints after U+10ffff are invalid
|
|
|
|
|
|
|
|
return code;
|
|
|
|
}
|
2019-10-28 22:53:32 +03:00
|
|
|
|
|
|
|
// Encode codepoint into utf8 text (char array length returned as parameter)
|
|
|
|
RLAPI const char *CodepointToUtf8(int codepoint, int *byteLength)
|
|
|
|
{
|
|
|
|
static char utf8[6] = { 0 };
|
|
|
|
int length = 0;
|
|
|
|
|
|
|
|
if (codepoint <= 0x7f)
|
|
|
|
{
|
|
|
|
utf8[0] = (char)codepoint;
|
|
|
|
length = 1;
|
|
|
|
}
|
|
|
|
else if (codepoint <= 0x7ff)
|
|
|
|
{
|
|
|
|
utf8[0] = (char)(((codepoint >> 6) & 0x1f) | 0xc0);
|
|
|
|
utf8[1] = (char)((codepoint & 0x3f) | 0x80);
|
|
|
|
length = 2;
|
|
|
|
}
|
|
|
|
else if (codepoint <= 0xffff)
|
|
|
|
{
|
|
|
|
utf8[0] = (char)(((codepoint >> 12) & 0x0f) | 0xe0);
|
|
|
|
utf8[1] = (char)(((codepoint >> 6) & 0x3f) | 0x80);
|
|
|
|
utf8[2] = (char)((codepoint & 0x3f) | 0x80);
|
|
|
|
length = 3;
|
|
|
|
}
|
|
|
|
else if (codepoint <= 0x10ffff)
|
|
|
|
{
|
|
|
|
utf8[0] = (char)(((codepoint >> 18) & 0x07) | 0xf0);
|
|
|
|
utf8[1] = (char)(((codepoint >> 12) & 0x3f) | 0x80);
|
|
|
|
utf8[2] = (char)(((codepoint >> 6) & 0x3f) | 0x80);
|
|
|
|
utf8[3] = (char)((codepoint & 0x3f) | 0x80);
|
|
|
|
length = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
*byteLength = length;
|
|
|
|
|
|
|
|
return utf8;
|
|
|
|
}
|
2018-12-26 15:26:34 +03:00
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
|
2013-11-19 02:38:44 +04:00
|
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Module specific Functions Definition
|
|
|
|
//----------------------------------------------------------------------------------
|
2017-03-26 23:49:01 +03:00
|
|
|
#if defined(SUPPORT_FILEFORMAT_FNT)
|
2016-01-02 12:45:51 +03:00
|
|
|
// Load a BMFont file (AngelCode font file)
|
2018-05-04 17:59:48 +03:00
|
|
|
static Font LoadBMFont(const char *fileName)
|
2013-12-19 15:08:06 +04:00
|
|
|
{
|
2016-01-02 12:45:51 +03:00
|
|
|
#define MAX_BUFFER_SIZE 256
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2018-05-04 17:59:48 +03:00
|
|
|
Font font = { 0 };
|
2016-01-02 12:45:51 +03:00
|
|
|
font.texture.id = 0;
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2018-10-18 17:00:11 +03:00
|
|
|
char buffer[MAX_BUFFER_SIZE] = { 0 };
|
2016-01-02 12:45:51 +03:00
|
|
|
char *searchPoint = NULL;
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
int fontSize = 0;
|
2018-10-18 17:00:11 +03:00
|
|
|
int texWidth = 0;
|
|
|
|
int texHeight = 0;
|
2018-02-25 04:55:32 +03:00
|
|
|
char texFileName[129];
|
2017-02-05 04:59:39 +03:00
|
|
|
int charsCount = 0;
|
2015-02-02 02:53:49 +03:00
|
|
|
|
2018-10-18 17:00:11 +03:00
|
|
|
int base = 0; // Useless data
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2018-10-18 17:00:11 +03:00
|
|
|
FILE *fntFile = NULL;
|
2015-02-02 02:53:49 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
fntFile = fopen(fileName, "rt");
|
2015-02-02 02:53:49 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
if (fntFile == NULL)
|
|
|
|
{
|
2017-07-02 13:35:13 +03:00
|
|
|
TraceLog(LOG_WARNING, "[%s] FNT file could not be opened", fileName);
|
2016-01-02 12:45:51 +03:00
|
|
|
return font;
|
|
|
|
}
|
2015-02-02 02:53:49 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
// NOTE: We skip first line, it contains no useful information
|
|
|
|
fgets(buffer, MAX_BUFFER_SIZE, fntFile);
|
|
|
|
//searchPoint = strstr(buffer, "size");
|
|
|
|
//sscanf(searchPoint, "size=%i", &fontSize);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
fgets(buffer, MAX_BUFFER_SIZE, fntFile);
|
|
|
|
searchPoint = strstr(buffer, "lineHeight");
|
|
|
|
sscanf(searchPoint, "lineHeight=%i base=%i scaleW=%i scaleH=%i", &fontSize, &base, &texWidth, &texHeight);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2017-07-02 13:35:13 +03:00
|
|
|
TraceLog(LOG_DEBUG, "[%s] Font size: %i", fileName, fontSize);
|
|
|
|
TraceLog(LOG_DEBUG, "[%s] Font texture scale: %ix%i", fileName, texWidth, texHeight);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
fgets(buffer, MAX_BUFFER_SIZE, fntFile);
|
|
|
|
searchPoint = strstr(buffer, "file");
|
|
|
|
sscanf(searchPoint, "file=\"%128[^\"]\"", texFileName);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2017-07-02 13:35:13 +03:00
|
|
|
TraceLog(LOG_DEBUG, "[%s] Font texture filename: %s", fileName, texFileName);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
fgets(buffer, MAX_BUFFER_SIZE, fntFile);
|
|
|
|
searchPoint = strstr(buffer, "count");
|
2017-02-05 04:59:39 +03:00
|
|
|
sscanf(searchPoint, "count=%i", &charsCount);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2017-07-02 13:35:13 +03:00
|
|
|
TraceLog(LOG_DEBUG, "[%s] Font num chars: %i", fileName, charsCount);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
// Compose correct path using route of .fnt file (fileName) and texFileName
|
|
|
|
char *texPath = NULL;
|
|
|
|
char *lastSlash = NULL;
|
|
|
|
|
2016-07-06 21:02:15 +03:00
|
|
|
lastSlash = strrchr(fileName, '/');
|
2019-02-22 14:12:21 +03:00
|
|
|
if (lastSlash == NULL)
|
|
|
|
{
|
|
|
|
lastSlash = strrchr(fileName, '\\');
|
|
|
|
}
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-07-06 21:02:15 +03:00
|
|
|
// NOTE: We need some extra space to avoid memory corruption on next allocations!
|
2019-04-23 15:55:35 +03:00
|
|
|
texPath = RL_MALLOC(strlen(fileName) - strlen(lastSlash) + strlen(texFileName) + 4);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-07-06 21:02:15 +03:00
|
|
|
// NOTE: strcat() and strncat() required a '\0' terminated string to work!
|
|
|
|
*texPath = '\0';
|
|
|
|
strncat(texPath, fileName, strlen(fileName) - strlen(lastSlash) + 1);
|
|
|
|
strncat(texPath, texFileName, strlen(texFileName));
|
2016-01-02 12:45:51 +03:00
|
|
|
|
2017-07-02 13:35:13 +03:00
|
|
|
TraceLog(LOG_DEBUG, "[%s] Font texture loading path: %s", fileName, texPath);
|
2017-01-29 01:02:30 +03:00
|
|
|
|
2016-10-24 20:11:29 +03:00
|
|
|
Image imFont = LoadImage(texPath);
|
2017-01-29 01:02:30 +03:00
|
|
|
|
|
|
|
if (imFont.format == UNCOMPRESSED_GRAYSCALE)
|
2016-11-21 21:47:58 +03:00
|
|
|
{
|
2019-10-17 18:07:09 +03:00
|
|
|
// Convert image to GRAYSCALE + ALPHA, using the mask as the alpha channel
|
|
|
|
ImageAlphaMask(&imFont, imFont);
|
|
|
|
for (int p = 0; p < (imFont.width*imFont.height*2); p += 2) ((unsigned char *)(imFont.data))[p] = 0xff;
|
2016-11-21 21:47:58 +03:00
|
|
|
}
|
2019-10-17 18:18:03 +03:00
|
|
|
|
2019-10-17 18:07:09 +03:00
|
|
|
font.texture = LoadTextureFromImage(imFont);
|
2018-11-06 17:10:50 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
RL_FREE(texPath);
|
2017-01-29 01:02:30 +03:00
|
|
|
|
2018-05-20 01:37:16 +03:00
|
|
|
// Fill font characters info data
|
2017-02-05 04:59:39 +03:00
|
|
|
font.baseSize = fontSize;
|
|
|
|
font.charsCount = charsCount;
|
2019-04-23 15:55:35 +03:00
|
|
|
font.chars = (CharInfo *)RL_MALLOC(charsCount*sizeof(CharInfo));
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
font.recs = (Rectangle *)RL_MALLOC(charsCount*sizeof(Rectangle));
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
int charId, charX, charY, charWidth, charHeight, charOffsetX, charOffsetY, charAdvanceX;
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2017-02-05 04:59:39 +03:00
|
|
|
for (int i = 0; i < charsCount; i++)
|
2016-01-02 12:45:51 +03:00
|
|
|
{
|
|
|
|
fgets(buffer, MAX_BUFFER_SIZE, fntFile);
|
2016-08-16 12:09:55 +03:00
|
|
|
sscanf(buffer, "char id=%i x=%i y=%i width=%i height=%i xoffset=%i yoffset=%i xadvance=%i",
|
2016-01-02 12:45:51 +03:00
|
|
|
&charId, &charX, &charY, &charWidth, &charHeight, &charOffsetX, &charOffsetY, &charAdvanceX);
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Get character rectangle in the font atlas texture
|
|
|
|
font.recs[i] = (Rectangle){ (float)charX, (float)charY, (float)charWidth, (float)charHeight };
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
// Save data properly in sprite font
|
2017-02-05 04:59:39 +03:00
|
|
|
font.chars[i].value = charId;
|
|
|
|
font.chars[i].offsetX = charOffsetX;
|
|
|
|
font.chars[i].offsetY = charOffsetY;
|
|
|
|
font.chars[i].advanceX = charAdvanceX;
|
2019-10-17 18:18:03 +03:00
|
|
|
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
// Fill character image data from imFont data
|
2019-10-17 18:07:09 +03:00
|
|
|
font.chars[i].image = ImageFromImage(imFont, font.recs[i]);
|
2016-01-02 12:45:51 +03:00
|
|
|
}
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2019-10-17 18:07:09 +03:00
|
|
|
UnloadImage(imFont);
|
BREAKING CHANGE: Read description
Changes:
- Font structure has been redesigned, CharInfo structure contained character rectangle within font texture, it has not much sense, considering that it was an information relative to the font atlas generated and not the character itself, so character rectangles have been moved out from CharInfo to Font.
- CharInfo included a data parameters to contain character pixel data (usually grayscale), generated on TTF font generation. It was inconsistent with other fonts types, so, now CharInfo includes directly an Image of the glyph.
- REDESIGNED: GenImageFontAtlas(), additional recs parameter added, loaded and filled inside the function to export atlas characters rectangles, instead of silently modify the input CharInfo data.
- REVIEWED: ImageTextEx(), funtion retrieved the font atlas image from the GPU, that was slow and problematic in several platforms. Now it uses directly the CharInfo image. Support for unicode codepoints has also been added.
- REDESIGNED: ImageDraw(), now it includes an additional parameter, the color tint, not only it could be useful for several situations but also function signature is more consistent with similar functions.
- ADDED: ImageFromImage() to generate a new image from a piece of another image.
- REVIEWED: GetNextCodepoint(), renamed parameters to be more clear.
Also all examples and games that were affected by those changes have been reviewed.
2019-07-24 16:05:14 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
fclose(fntFile);
|
2016-08-16 12:09:55 +03:00
|
|
|
|
2016-11-01 02:58:21 +03:00
|
|
|
if (font.texture.id == 0)
|
2016-03-02 20:35:30 +03:00
|
|
|
{
|
2018-05-04 17:59:48 +03:00
|
|
|
UnloadFont(font);
|
2018-07-05 20:17:06 +03:00
|
|
|
font = GetFontDefault();
|
2016-03-02 20:35:30 +03:00
|
|
|
}
|
2018-05-04 17:59:48 +03:00
|
|
|
else TraceLog(LOG_INFO, "[%s] Font loaded successfully", fileName);
|
2015-02-02 02:53:49 +03:00
|
|
|
|
2016-01-02 12:45:51 +03:00
|
|
|
return font;
|
|
|
|
}
|
2019-01-24 06:28:10 +03:00
|
|
|
#endif
|