john/prosperon
1
0
Fork 0
Code Issues Pull requests Actions Releases Activity
prosperon/source/engine/font.c
John Alanbrook 0f8a466354 wk
2023-05-05 03:39:23 +00:00

358 lines
9.1 KiB
C
Raw Blame History

#include "font.h"
#include "render.h"
#include <shader.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <stdlib.h>
#include <window.h>
#include "log.h"
#include "openglrender.h"
#include "stb_truetype.h"
#include "stb_rect_pack.h"
#include "stb_image_write.h"
struct sFont *font;
static struct shader *shader;
static sg_shader fontshader;
unsigned char *slurp_file(const char *filename) {
FILE *f = fopen(filename, "rb");
if (!f) return NULL;
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
fseek(f, 0, SEEK_SET);
unsigned char *slurp = malloc(fsize+1);
fread(slurp,fsize,1,f);
fclose(f);
return slurp;
}
char *slurp_text(const char *filename) {
FILE *f = fopen(filename, "r'");
if (!f) return NULL;
char *buf;
long int fsize;
fseek(f, 0, SEEK_END);
fsize = ftell(f);
buf = malloc(fsize+1);
rewind(f);
size_t r = fread(buf, sizeof(char), fsize, f);
buf[r] = '\0';
fclose(f);
return buf;
}
int slurp_write(const char *txt, const char *filename)
{
FILE *f = fopen(filename, "w");
if (!f) return 1;
fputs(txt, f);
fclose(f);
return 0;
}
static sg_bindings bind_text;
static sg_pipeline pipe_text;
void font_init(struct shader *textshader) {
shader = textshader;
fontshader = sg_make_shader(&(sg_shader_desc){
.vs.source = slurp_text("shaders/textvert.glsl"),
.fs.source = slurp_text("shaders/textfrag.glsl"),
.vs.uniform_blocks[0] = {
.size = sizeof(float)*16,
.layout = SG_UNIFORMLAYOUT_STD140,
.uniforms = {
[0] = { .name = "projection", .type = SG_UNIFORMTYPE_MAT4 }
}
},
.fs.uniform_blocks[0] = {
.size = sizeof(float)*3+sizeof(int),
.layout = SG_UNIFORMLAYOUT_STD140,
.uniforms = {
[0] = { .name = "textColor", .type = SG_UNIFORMTYPE_FLOAT3 },
[1] = { .name = "invert", .type = SG_UNIFORMTYPE_INT }
}
},
.fs.images[0] = {
.name = "text",
.image_type = SG_IMAGETYPE_2D,
.sampler_type = SG_SAMPLERTYPE_FLOAT
}
});
pipe_text = sg_make_pipeline(&(sg_pipeline_desc){
.shader = fontshader,
.layout = {
.attrs = { [0].format = SG_VERTEXFORMAT_FLOAT4 }
},
.primitive_type = SG_PRIMITIVETYPE_TRIANGLE_STRIP,
.label = "text pipeline"
});
bind_text.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
.size = sizeof(float)*16,
.type = SG_BUFFERTYPE_VERTEXBUFFER,
.usage = SG_USAGE_STREAM,
.label = "text buffer"
});
font = MakeFont("LessPerfectDOSVGA.ttf", 16);
}
void font_frame(struct window *w) {
shader_use(shader);
}
struct sFont *MakeFont(const char *fontfile, int height)
{
YughInfo("Making font %s.", fontfile);
int packsize = 128;
struct sFont *newfont = calloc(1, sizeof(struct sFont));
newfont->height = height;
char fontpath[256];
snprintf(fontpath, 256, "fonts/%s", fontfile);
unsigned char *ttf_buffer = slurp_file(fontpath);
unsigned char *bitmap = malloc(packsize*packsize);
stbtt_packedchar glyphs[95];
stbtt_pack_context pc;
stbtt_PackBegin(&pc, bitmap, packsize, packsize, 0, 1, NULL);
stbtt_PackFontRange(&pc, ttf_buffer, 0, height, 32, 95, glyphs);
stbtt_PackEnd(&pc);
stbi_write_png("packedfont.png", packsize, packsize, 1, bitmap, sizeof(char) * packsize);
stbtt_fontinfo fontinfo;
if (!stbtt_InitFont(&fontinfo, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0))) {
YughError("Failed to make font %s", fontfile);
}
newfont->texID = sg_make_image(&(sg_image_desc){
.type = SG_IMAGETYPE_2D,
.width = packsize,
.height = packsize,
.pixel_format = SG_PIXELFORMAT_R8,
.usage = SG_USAGE_IMMUTABLE,
.min_filter = SG_FILTER_NEAREST,
.mag_filter = SG_FILTER_NEAREST,
.data.subimage[0][0] = {
.ptr = bitmap,
.size = packsize*packsize
}
});
free(ttf_buffer);
free(bitmap);
for (unsigned char c = 32; c < 127; c++) {
stbtt_packedchar glyph = glyphs[c-32];
struct glrect r;
r.s0 = glyph.x0 / (float) packsize;
r.s1 = glyph.x1 / (float) packsize;
r.t0 = glyph.y0 / (float) packsize;
r.t1 = glyph.y1 / (float) packsize;
newfont->Characters[c].Advance = glyph.xadvance;
newfont->Characters[c].Size[0] = glyph.x1 - glyph.x0;
newfont->Characters[c].Size[1] = glyph.y1 - glyph.y0;
newfont->Characters[c].Bearing[0] = glyph.xoff;
newfont->Characters[c].Bearing[1] = glyph.yoff2;
newfont->Characters[c].rect = r;
}
return newfont;
}
static int curchar = 0;
void draw_char_box(struct Character c, float cursor[2], float scale, float color[3])
{
int x, y, w, h;
x = cursor[0];
y = cursor[1];
w = 8*scale;
h = 14;
x += w/2.f;
y += h/2.f;
draw_rect(x,y,w,h,color);
}
void fill_charverts(float *verts, float cursor[2], float scale, struct Character c, float *offset)
{
float w = c.Size[0] * scale;
float h = c.Size[1] * scale;
float xpos = cursor[0] + (c.Bearing[0]+offset[0]) * scale;
float ypos = cursor[1] - (c.Bearing[1]+offset[1]) * scale;
float v[16] = {
xpos, ypos, c.rect.s0, c.rect.t1,
xpos+w, ypos, c.rect.s1, c.rect.t1,
xpos, ypos + h, c.rect.s0, c.rect.t0,
xpos + w, ypos + h, c.rect.s1, c.rect.t0
};
memcpy(verts, v, sizeof(float)*16);
}
static int drawcaret = 0;
void sdrawCharacter(struct Character c, mfloat_t cursor[2], float scale, struct shader *shader, float color[3])
{
float shadowcolor[3] = {0.f, 0.f, 0.f};
float shadowcursor[2];
float verts[16];
float offset[2] = {-1, 1};
fill_charverts(verts, cursor, scale, c, offset);
curchar++;
/* Check if the vertex is off screen */
if (verts[5] < 0 || verts[10] < 0 || verts[0] > window_i(0)->width || verts[1] > window_i(0)->height)
return;
/*
if (drawcaret == curchar) {
draw_char_box(c, cursor, scale, color);
shader_use(shader);
shader_setvec3(shader, "textColor", color);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, font->texID);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
}
*/
shader_setvec3(shader, "textColor", shadowcolor);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
offset[0] = 1;
offset[1] = -1;
fill_charverts(verts, cursor, scale, c, offset);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
offset[1] = 1;
fill_charverts(verts, cursor, scale, c, offset);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
offset[0] = -1;
offset[1] = -1;
fill_charverts(verts, cursor, scale, c, offset);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
offset[0] = offset[1] = 0;
fill_charverts(verts, cursor, scale, c, offset);
shader_setvec3(shader, "textColor", color);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
}
void text_settype(struct sFont *mfont)
{
font = mfont;
}
int renderText(const char *text, mfloat_t pos[2], float scale, mfloat_t color[3], float lw, int caret)
{
int len = strlen(text);
drawcaret = caret;
mfloat_t cursor[2] = { 0.f };
cursor[0] = pos[0];
cursor[1] = pos[1];
sg_apply_pipeline(pipe_text);
sg_apply_bindings(&bind_text);
sg_apply_uniforms(SG_SHADERSTAGE_FS,0,color);
const unsigned char *line, *wordstart, *drawstart;
line = drawstart = (unsigned char*)text;
curchar = 0;
float *usecolor = color;
while (*line != '\0') {
switch (*line) {
case '\n':
sdrawCharacter(font->Characters[*line], cursor, scale, shader, usecolor);
cursor[1] -= scale * font->height;
cursor[0] = pos[0];
line++;
break;
case ' ':
sdrawCharacter(font->Characters[*line], cursor, scale, shader, usecolor);
cursor[0] += font->Characters[*line].Advance * scale;
line++;
break;
case '\t':
sdrawCharacter(font->Characters[*line], cursor, scale, shader, usecolor);
cursor[0] += font->Characters[*line].Advance * scale;
line++;
break;
default:
wordstart = line;
int wordWidth = 0;
while (!isspace(*line) && *line != '\0') {
wordWidth += font->Characters[*line].Advance * scale;
line++;
}
if (lw > 0 && (cursor[0] + wordWidth - pos[0]) >= lw) {
cursor[0] = pos[0];
cursor[1] -= scale * font->height;
}
while (wordstart < line) {
sdrawCharacter(font->Characters[*wordstart], cursor, scale, shader, usecolor);
cursor[0] += font->Characters[*wordstart].Advance * scale;
wordstart++;
}
}
}
if (caret > curchar) {
draw_char_box(font->Characters[69], cursor, scale, color);
}
return cursor[1] - pos[1];
}
Reference in a new issue View git blame Copy permalink