Wellspring/src/Wellspring.c

485 lines
14 KiB
C
Raw Normal View History

2022-04-13 03:00:50 +00:00
/* Wellspring - An immediate mode font rendering system in C
2022-04-12 01:42:22 +00:00
*
* Copyright (c) 2022 Evan Hemsley
*
* This software is provided 'as-is', without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from
* the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 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 in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*
* Evan "cosmonaut" Hemsley <evan@moonside.games>
*
*/
2022-04-12 21:28:52 +00:00
#include "Wellspring.h"
2022-04-12 01:42:22 +00:00
2022-04-13 16:57:32 +00:00
/* Function defines */
#ifdef USE_SDL2
#define Wellspring_malloc SDL_malloc
#define Wellspring_realloc SDL_realloc
#define Wellspring_free SDL_free
#define Wellspring_memcpy SDL_memcpy
#define Wellspring_memset SDL_memset
#define Wellspring_ifloor(x) ((int) SDL_floorf(x))
#define Wellspring_iceil(x) ((int) SDL_ceilf(x))
#define Wellspring_sqrt SDL_sqrt
#define Wellspring_pow SDL_pow
#define Wellspring_fmod SDL_fmod
#define Wellspring_cos SDL_cos
#define Wellspring_acos SDL_acos
#define Wellspring_fabs SDL_fabs
#define Wellspring_assert SDL_assert
#define Wellspring_strlen SDL_strlen
#define Wellspring_sort SDL_qsort
#else
#ifdef _MSC_VER
#include <assert.h>
#include <stdlib.h>
#include <search.h>
#include <math.h>
#include <string.h>
#endif
#define Wellspring_malloc malloc
#define Wellspring_realloc realloc
#define Wellspring_free free
#define Wellspring_memcpy memcpy
#define Wellspring_memset memset
#define Wellspring_ifloor(x) ((int) floor(x))
#define Wellspring_iceil(x) ((int) ceil(x))
#define Wellspring_sqrt sqrt
#define Wellspring_pow pow
#define Wellspring_fmod fmod
#define Wellspring_cos cos
#define Wellspring_acos acos
#define Wellspring_fabs fabs
#define Wellspring_assert assert
#define Wellspring_strlen strlen
#define Wellspring_sort qsort
#endif
2022-04-12 01:42:22 +00:00
#define STBTT_malloc(x,u) ((void)(u),Wellspring_malloc(x))
#define STBTT_free(x,u) ((void)(u),Wellspring_free(x))
2022-04-12 19:08:37 +00:00
#define STBTT_memcpy Wellspring_memcpy
#define STBTT_memset Wellspring_memset
2022-04-12 01:42:22 +00:00
#define STBTT_ifloor Wellspring_ifloor
#define STBTT_iceil Wellspring_iceil
#define STBTT_sqrt Wellspring_sqrt
#define STBTT_pow Wellspring_pow
2022-04-12 19:08:37 +00:00
#define STBTT_fmod Wellspring_fmod
#define STBTT_cos Wellspring_cos
#define STBTT_acos Wellspring_acos
#define STBTT_fabs Wellspring_fabs
#define STBTT_assert Wellspring_assert
#define STBTT_strlen Wellspring_strlen
2022-04-13 02:29:19 +00:00
#define STBRP_SORT Wellspring_sort
#define STBRP_ASSERT Wellspring_assert
2022-04-12 19:08:37 +00:00
typedef uint8_t stbtt_uint8;
typedef int8_t stbtt_int8;
typedef uint16_t stbtt_uint16;
typedef int16_t stbtt_int16;
typedef uint32_t stbtt_uint32;
typedef int32_t stbtt_int32;
2022-04-12 01:42:22 +00:00
2022-04-13 02:29:19 +00:00
#pragma GCC diagnostic ignored "-Wunused-function"
#define STBRP_STATIC
#define STB_RECT_PACK_IMPLEMENTATION
#include "stb_rect_pack.h"
2022-04-12 01:42:22 +00:00
#define STBTT_STATIC
#define STB_TRUETYPE_IMPLEMENTATION
#include "stb_truetype.h"
2022-04-13 02:29:19 +00:00
#pragma GCC diagnostic warning "-Wunused-function"
2022-04-12 19:08:37 +00:00
#define INITIAL_QUAD_CAPACITY 128
/* Structs */
typedef struct CharRange
2022-04-12 01:42:22 +00:00
{
2022-04-12 19:08:37 +00:00
stbtt_packedchar *data;
2022-04-13 16:57:32 +00:00
uint32_t firstCodepoint;
2022-04-12 19:08:37 +00:00
uint32_t charCount;
} CharRange;
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
typedef struct Packer
2022-04-12 01:42:22 +00:00
{
2022-04-12 19:08:37 +00:00
uint8_t *fontBytes;
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
stbtt_pack_context *context;
uint8_t *pixels;
uint32_t width;
uint32_t height;
uint32_t strideInBytes;
uint32_t padding;
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
CharRange *ranges;
uint32_t rangeCount;
} Packer;
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
typedef struct Batch
{
Wellspring_Vertex *vertices;
uint32_t vertexCount;
uint32_t vertexCapacity;
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
uint32_t *indices;
uint32_t indexCount;
uint32_t indexCapacity;
2022-04-13 00:03:59 +00:00
Packer *currentPacker;
2022-04-12 19:08:37 +00:00
} Batch;
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
/* UTF-8 Decoder */
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
/* Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
* See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
*/
#define UTF8_ACCEPT 0
#define UTF8_REJECT 1
static const uint8_t utf8d[] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf
8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df
0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef
0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff
0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2
1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4
1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6
1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8
};
static uint32_t inline
decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
uint32_t type = utf8d[byte];
*codep = (*state != UTF8_ACCEPT) ?
(byte & 0x3fu) | (*codep << 6) :
(0xff >> type) & (byte);
*state = utf8d[256 + *state*16 + type];
return *state;
2022-04-12 01:42:22 +00:00
}
2022-04-12 19:08:37 +00:00
/* API */
uint32_t Wellspring_LinkedVersion(void)
{
return WELLSPRING_COMPILED_VERSION;
2022-04-12 01:42:22 +00:00
}
Wellspring_Packer* Wellspring_CreatePacker(
2022-04-12 22:15:51 +00:00
const uint8_t *fontBytes,
2022-04-12 19:08:37 +00:00
uint32_t fontBytesLength,
2022-04-12 01:42:22 +00:00
uint32_t width,
uint32_t height,
uint32_t strideInBytes,
uint32_t padding
) {
2022-04-12 19:08:37 +00:00
Packer *packer = Wellspring_malloc(sizeof(Packer));
packer->fontBytes = Wellspring_malloc(fontBytesLength);
Wellspring_memcpy(packer->fontBytes, fontBytes, fontBytesLength);
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
packer->context = Wellspring_malloc(sizeof(stbtt_pack_context));
packer->pixels = Wellspring_malloc(sizeof(uint8_t) * width * height);
packer->width = width;
packer->height = height;
packer->strideInBytes = strideInBytes;
packer->padding = padding;
packer->ranges = NULL;
packer->rangeCount = 0;
stbtt_PackBegin(packer->context, packer->pixels, width, height, strideInBytes, padding, NULL);
return (Wellspring_Packer*) packer;
2022-04-12 01:42:22 +00:00
}
uint32_t Wellspring_PackFontRanges(
Wellspring_Packer *packer,
Wellspring_FontRange *ranges,
uint32_t numRanges
) {
2022-04-12 19:08:37 +00:00
Packer *myPacker = (Packer*) packer;
Wellspring_FontRange *currentFontRange;
2022-04-13 16:57:32 +00:00
stbtt_pack_range* stbPackRanges = Wellspring_malloc(sizeof(stbtt_pack_range) * numRanges);
2022-04-12 19:08:37 +00:00
CharRange *currentCharRange;
uint32_t i;
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
for (i = 0; i < numRanges; i += 1)
{
currentFontRange = &ranges[i];
2022-04-13 16:57:32 +00:00
stbPackRanges[i].font_size = (float) currentFontRange->fontSize;
2022-04-12 19:08:37 +00:00
stbPackRanges[i].first_unicode_codepoint_in_range = currentFontRange->firstCodepoint;
stbPackRanges[i].array_of_unicode_codepoints = NULL;
stbPackRanges[i].num_chars = currentFontRange->numChars;
stbPackRanges[i].h_oversample = currentFontRange->oversampleH;
stbPackRanges[i].v_oversample = currentFontRange->oversampleV;
stbPackRanges[i].chardata_for_range = Wellspring_malloc(sizeof(stbtt_packedchar) * currentFontRange->numChars);
}
2022-04-12 01:42:22 +00:00
2022-04-12 21:31:56 +00:00
if (!stbtt_PackFontRanges(myPacker->context, myPacker->fontBytes, 0, stbPackRanges, numRanges))
{
/* Font packing failed, time to bail */
for (i = 0; i < numRanges; i += 1)
{
Wellspring_free(stbPackRanges[i].chardata_for_range);
}
return 0;
}
2022-04-12 19:08:37 +00:00
2022-04-13 02:29:19 +00:00
myPacker->ranges = Wellspring_realloc(myPacker->ranges, sizeof(CharRange) * (myPacker->rangeCount + numRanges));
2022-04-12 19:08:37 +00:00
for (i = 0; i < numRanges; i += 1)
{
currentCharRange = &myPacker->ranges[myPacker->rangeCount + i];
currentCharRange->data = stbPackRanges[i].chardata_for_range;
currentCharRange->firstCodepoint = stbPackRanges[i].first_unicode_codepoint_in_range;
currentCharRange->charCount = stbPackRanges[i].num_chars;
}
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
myPacker->rangeCount += numRanges;
2022-04-12 21:31:56 +00:00
return 1;
2022-04-12 01:42:22 +00:00
}
2022-04-12 23:38:09 +00:00
uint8_t* Wellspring_GetPixelDataPointer(
Wellspring_Packer *packer
2022-04-12 01:42:22 +00:00
) {
2022-04-12 19:08:37 +00:00
Packer* myPacker = (Packer*) packer;
2022-04-12 23:38:09 +00:00
return myPacker->pixels;
2022-04-12 19:08:37 +00:00
}
2022-04-12 22:15:51 +00:00
Wellspring_TextBatch* Wellspring_CreateTextBatch()
2022-04-12 19:08:37 +00:00
{
Batch *batch = Wellspring_malloc(sizeof(Batch));
batch->vertexCapacity = INITIAL_QUAD_CAPACITY * 4;
batch->vertices = Wellspring_malloc(sizeof(Wellspring_Vertex) * batch->vertexCapacity);
batch->vertexCount = 0;
batch->indexCapacity = INITIAL_QUAD_CAPACITY * 6;
batch->indices = Wellspring_malloc(sizeof(uint32_t) * batch->indexCapacity);
batch->indexCount = 0;
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
return (Wellspring_TextBatch*) batch;
2022-04-12 01:42:22 +00:00
}
2022-04-13 00:03:59 +00:00
void Wellspring_StartTextBatch(
Wellspring_TextBatch *textBatch,
Wellspring_Packer *packer
) {
2022-04-12 19:08:37 +00:00
Batch *batch = (Batch*) textBatch;
2022-04-13 00:03:59 +00:00
batch->currentPacker = (Packer*) packer;
2022-04-12 19:08:37 +00:00
batch->vertexCount = 0;
batch->indexCount = 0;
}
2022-04-12 22:15:51 +00:00
uint8_t Wellspring_Draw(
2022-04-12 19:08:37 +00:00
Wellspring_TextBatch *textBatch,
float x,
float y,
float depth,
Wellspring_Color *color,
const uint8_t *str,
uint32_t strLength
) {
Batch *batch = (Batch*) textBatch;
2022-04-13 00:03:59 +00:00
Packer *myPacker = batch->currentPacker;
2022-04-12 19:08:37 +00:00
uint32_t decodeState = 0;
uint32_t codepoint;
int32_t glyphIndex;
int32_t previousGlyphIndex;
stbtt_packedchar *rangeData;
stbtt_aligned_quad charQuad;
uint32_t vertexBufferIndex;
uint32_t indexBufferIndex;
2022-04-13 02:29:19 +00:00
uint32_t i, j;
2022-04-12 19:08:37 +00:00
for (i = 0; i < strLength; i += 1)
{
if (decode(&decodeState, &codepoint, str[i]))
{
if (decodeState == UTF8_REJECT)
{
/* Something went very wrong */
return 0;
}
continue;
}
2022-04-13 02:29:19 +00:00
rangeData = NULL;
2022-04-12 19:08:37 +00:00
/* Find the packed char data */
2022-04-13 02:29:19 +00:00
for (j = 0; j < myPacker->rangeCount; j += 1)
2022-04-12 19:08:37 +00:00
{
if (
2022-04-13 02:29:19 +00:00
codepoint >= myPacker->ranges[j].firstCodepoint &&
codepoint < myPacker->ranges[j].firstCodepoint + myPacker->ranges[j].charCount
2022-04-12 19:08:37 +00:00
) {
2022-04-13 02:29:19 +00:00
rangeData = myPacker->ranges[j].data;
glyphIndex = codepoint - myPacker->ranges[j].firstCodepoint;
break;
2022-04-12 19:08:37 +00:00
}
}
2022-04-13 02:29:19 +00:00
if (rangeData == NULL)
{
/* Requested char wasn't packed! */
return 0;
}
2022-04-12 19:08:37 +00:00
stbtt_GetPackedQuad(
rangeData,
myPacker->width,
myPacker->height,
glyphIndex,
&x,
&y,
&charQuad,
1
);
if (batch->vertexCount >= batch->vertexCapacity)
{
batch->vertexCapacity *= 2;
batch->vertices = Wellspring_realloc(batch->vertices, sizeof(Wellspring_Vertex) * batch->vertexCapacity);
}
if (batch->indexCount >= batch->indexCapacity)
{
batch->indexCapacity *= 2;
batch->indices = Wellspring_realloc(batch->indices, sizeof(uint32_t) * batch->indexCapacity);
}
/* TODO: kerning and alignment */
2022-04-12 01:42:22 +00:00
2022-04-12 19:08:37 +00:00
vertexBufferIndex = batch->vertexCount;
indexBufferIndex = batch->indexCount;
batch->vertices[vertexBufferIndex].x = charQuad.x0;
batch->vertices[vertexBufferIndex].y = charQuad.y0;
batch->vertices[vertexBufferIndex].z = depth;
batch->vertices[vertexBufferIndex].u = charQuad.s0;
batch->vertices[vertexBufferIndex].v = charQuad.t0;
batch->vertices[vertexBufferIndex].r = color->r;
batch->vertices[vertexBufferIndex].g = color->g;
batch->vertices[vertexBufferIndex].b = color->b;
batch->vertices[vertexBufferIndex].a = color->a;
batch->vertices[vertexBufferIndex + 1].x = charQuad.x0;
batch->vertices[vertexBufferIndex + 1].y = charQuad.y1;
batch->vertices[vertexBufferIndex + 1].z = depth;
batch->vertices[vertexBufferIndex + 1].u = charQuad.s0;
batch->vertices[vertexBufferIndex + 1].v = charQuad.t1;
batch->vertices[vertexBufferIndex + 1].r = color->r;
batch->vertices[vertexBufferIndex + 1].g = color->g;
batch->vertices[vertexBufferIndex + 1].b = color->b;
batch->vertices[vertexBufferIndex + 1].a = color->a;
batch->vertices[vertexBufferIndex + 2].x = charQuad.x1;
batch->vertices[vertexBufferIndex + 2].y = charQuad.y0;
batch->vertices[vertexBufferIndex + 2].z = depth;
batch->vertices[vertexBufferIndex + 2].u = charQuad.s1;
batch->vertices[vertexBufferIndex + 2].v = charQuad.t0;
batch->vertices[vertexBufferIndex + 2].r = color->r;
batch->vertices[vertexBufferIndex + 2].g = color->g;
batch->vertices[vertexBufferIndex + 2].b = color->b;
batch->vertices[vertexBufferIndex + 2].a = color->a;
batch->vertices[vertexBufferIndex + 3].x = charQuad.x1;
batch->vertices[vertexBufferIndex + 3].y = charQuad.y1;
batch->vertices[vertexBufferIndex + 3].z = depth;
batch->vertices[vertexBufferIndex + 3].u = charQuad.s1;
batch->vertices[vertexBufferIndex + 3].v = charQuad.t1;
batch->vertices[vertexBufferIndex + 3].r = color->r;
batch->vertices[vertexBufferIndex + 3].g = color->g;
batch->vertices[vertexBufferIndex + 3].b = color->b;
batch->vertices[vertexBufferIndex + 3].a = color->a;
batch->indices[indexBufferIndex] = vertexBufferIndex;
batch->indices[indexBufferIndex + 1] = vertexBufferIndex + 1;
batch->indices[indexBufferIndex + 2] = vertexBufferIndex + 2;
batch->indices[indexBufferIndex + 3] = vertexBufferIndex + 2;
batch->indices[indexBufferIndex + 4] = vertexBufferIndex + 1;
batch->indices[indexBufferIndex + 5] = vertexBufferIndex + 3;
batch->vertexCount += 4;
batch->indexCount += 6;
}
return 1;
2022-04-12 01:42:22 +00:00
}
2022-04-12 19:08:37 +00:00
2022-04-12 22:15:51 +00:00
void Wellspring_GetBufferData(
2022-04-12 19:08:37 +00:00
Wellspring_TextBatch *textBatch,
2022-04-12 23:38:09 +00:00
Wellspring_Vertex **pVertexBuffer,
uint32_t *pVertexBufferLengthInBytes,
uint32_t **pIndexBuffer,
uint32_t *pIndexBufferLengthInBytes
2022-04-12 19:08:37 +00:00
) {
Batch *batch = (Batch*) textBatch;
2022-04-12 23:38:09 +00:00
*pVertexBuffer = batch->vertices;
*pVertexBufferLengthInBytes = batch->vertexCount * sizeof(Wellspring_Vertex);
*pIndexBuffer = batch->indices;
*pIndexBufferLengthInBytes = batch->indexCount * sizeof(uint32_t);
2022-04-12 19:08:37 +00:00
}
2022-04-12 22:15:51 +00:00
void Wellspring_DestroyTextBatch(Wellspring_TextBatch *textBatch)
2022-04-12 19:08:37 +00:00
{
Batch *batch = (Batch*) textBatch;
Wellspring_free(batch->vertices);
Wellspring_free(batch->indices);
Wellspring_free(batch);
}
void Wellspring_DestroyPacker(Wellspring_Packer *packer)
{
Packer* myPacker = (Packer*) packer;
2022-04-12 21:31:56 +00:00
uint32_t i;
2022-04-13 02:29:19 +00:00
stbtt_PackEnd(myPacker->context);
2022-04-12 21:31:56 +00:00
for (i = 0; i < myPacker->rangeCount; i += 1)
{
Wellspring_free(myPacker->ranges[i].data);
}
2022-04-12 01:42:22 +00:00
2022-04-12 21:31:56 +00:00
Wellspring_free(myPacker->ranges);
2022-04-12 19:08:37 +00:00
Wellspring_free(myPacker->fontBytes);
Wellspring_free(myPacker->context);
Wellspring_free(myPacker->pixels);
2022-04-12 01:42:22 +00:00
}