piu errori

text_rendering/Makefile

@@ -1,7 +1,7 @@
-LDFLAGS = -lm -lgrapheme
+LDFLAGS = -lm -lgrapheme -lSDL2 -lGLEW -lGL
 CFLAGS = -g -Wall -Wextra -pedantic
-SOURCE = main.c font.c cache.c hash.c util.c
+SOURCE = main.c font.c cache.c hash.c util.c ren.c
-HEADER = font.h hash.h cache.h util.h
+HEADER = font.h hash.h cache.h util.h ren.h
 
 test: ${HEADER} ${SOURCE}
 	gcc ${CFLAGS} ${LDFLAGS} ${SOURCE} -o test

text_rendering/cache.c

@@ -16,13 +16,14 @@ static struct hm_ref *hash_table;
 static struct font_glyph cache_array[CACHE_SIZE] = {0};
 
 // bitmap size is aligned to word
-#define _BSIZE ((CACHE_SIZE+0x3f)&(~0x3f))
+// 2^6 == 64 bits, number of bits in a uint64_t
+#define _BSIZE (((CACHE_SIZE+0x3f)&(~0x3f))>>6)
 static uint64_t bitmap[_BSIZE] = {0};
 
 // bitmap operations
-#define B_RESET() memset(bitmap, 0, _BSIZE*sizeof(uint64_t))
+#define B_RESET() for (int i = 0; i < _BSIZE; bitmap[i++] = 0);
-#define B_SET(x)  bitmap[(x)/_BSIZE] |= 1<<((x)%_BSIZE)
+#define B_SET(x)  bitmap[(x)>>6] |= (uint64_t)1<<((x)%64)
-#define B_TEST(x) (bitmap[(x)/_BSIZE]&(1<<((x)%_BSIZE)))
+#define B_TEST(x) (bitmap[(x)>>6]&((uint64_t)1<<((x)%64)))
 
 // reset the bitmap every n cycles
 #define NCYCLES (CACHE_SIZE/2)
@@ -71,6 +72,18 @@ unsigned int cache_get(void)
 	// find an open spot in the cache
 	// TODO: use __builtin_clz to speed this up
 	for (; x < CACHE_SIZE; x++) {
+		//printf("testing spot %d\n", x);
+		//print_byte(bitmap[0]>>56);
+		//print_byte(bitmap[0]>>48);
+		//print_byte(bitmap[0]>>40);
+		//print_byte(bitmap[0]>>32);
+		//print_byte(bitmap[0]>>24);
+		//print_byte(bitmap[0]>>16);
+		//print_byte(bitmap[0]>>8);
+		//print_byte(bitmap[0]);
+		//printf("%lx", bitmap[i]);
+		//printf("\n");
+
 		if (!B_TEST(x))
 			break;
 	}

text_rendering/font.c

@@ -1,49 +1,33 @@
 #define _POSIX_C_SOURCE 200809l
 #define STB_TRUETYPE_IMPLEMENTATION
 #define STBTT_STATIC
-#define MSDF_IMPLEMENTATION
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 
 #include <grapheme.h>
 #include <assert.h>
 
 #include "font.h"
-#include "msdf_c/stb_truetype.h"
+#include "stb_truetype.h"
-#include "msdf_c/msdf.h"
 #include "stb_image_write.h"
 #include "util.h"
 #include "cache.h"
 
 
 #define UTF8(c) (c&0x80)
-#define BDEPTH 3
+#define BDEPTH 1
 #define BORDER 4
 
-// Generates a cached atlas of font glyphs encoded usign a signed distance field
+// FIXME: as of now only monospaced fonts work correctly since no kerning information
-// https://www.youtube.com/watch?v=1b5hIMqz_wM
+// is stored 
-// https://github.com/pjako/msdf_c
-// this way the texture atlas for the font will be bigger but we save up the space
-// needed for rendering the font in multiple sizes
 
 
-struct font_atlas {
+struct priv {
-	unsigned int glyphs, width, height;
-	unsigned char *atlas;
-
-	struct {
 	stbtt_fontinfo stb;
-		msdf_AllocCtx ctx;
-		msdf_Result msdf;
 	float scale;
-	} priv;
+	int baseline;
-
+	unsigned char *bitmap;
-	int file_size;
-	unsigned char *file;
 };
-
+#define PRIV(x) ((struct priv *)x->priv)
-
-const unsigned int glyph_w = 32;
-const unsigned int glyph_h = 32;
 
 
 // only useful for msdf_c
@@ -53,12 +37,17 @@ static inline void _efree(void *x, void *_) { (void)_; efree(x); }
 
 struct font_atlas * font_init(void)
 {
-	return emalloc(sizeof(struct font_atlas));
+	struct font_atlas *p = emalloc(sizeof(struct font_atlas));
+	memset(p, 0, sizeof(struct font_atlas));
+	p->priv = emalloc(sizeof(struct priv));
+	memset(p->priv, 0, sizeof(struct priv));
+	return p;
 }
 
 
-// loads a font into memory, storing all the ASCII characters in the atlas
+// loads a font into memory, storing all the ASCII characters in the atlas, each font
-int font_load(struct font_atlas *atlas, const char *path)
+// atlas structure holds glyphs of a specific size
+int font_load(struct font_atlas *atlas, const char *path, int size)
 {
 	if (!atlas || !path)
 		return -1;
@@ -67,28 +56,36 @@ int font_load(struct font_atlas *atlas, const char *path)
 
 	dump_file(path, &(atlas->file), &(atlas->file_size));
 
-	err = stbtt_InitFont(&(atlas->priv.stb), atlas->file, 0);
+	err = stbtt_InitFont(&(PRIV(atlas)->stb), (unsigned char *)atlas->file, 0);
 	ERROR(err == 0, -1);
 
-	atlas->priv.scale = stbtt_ScaleForPixelHeight(&(atlas->priv.stb), glyph_h);
+	int ascent, descent, linegap, baseline;
-	//int ascent, descent, linegap, baseline;
+	int x0,y0,x1,y1;
-	//int x0,y0,x1,y1;
+	float scale;
-	//stbtt_GetFontVMetrics(&(atlas->priv.stb), &ascent, &descent, &linegap);
+	scale = stbtt_ScaleForPixelHeight(&(PRIV(atlas)->stb), size);
-	//stbtt_GetFontBoundingBox(&(atlas->priv.stb), &x0, &y0, &x1, &y1);
+	stbtt_GetFontVMetrics(&(PRIV(atlas)->stb), &ascent, &descent, &linegap);
-	//baseline = atlas->priv.scale * -y0;
+	stbtt_GetFontBoundingBox(&(PRIV(atlas)->stb), &x0, &y0, &x1, &y1);
-	//atlas->glyph_max_w = (atlas->priv.scale*x1) - (atlas->priv.scale*x0);
+	baseline = scale * -y0;
-	//atlas->glyph_max_h = (baseline+atlas->priv.scale*y1) - (baseline+atlas->priv.scale*y0);
+	atlas->glyph_max_w = (scale*x1) - (scale*x0);
-	//atlas->atlas = emalloc(atlas->glyph_max_w*atlas->glyph_max_h*CACHE_SIZE);
+	atlas->glyph_max_h = (baseline+scale*y1) - (baseline+scale*y0);
-
+	atlas->atlas = emalloc(CACHE_SIZE*BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
-	atlas->atlas  = ecalloc(CACHE_SIZE, BDEPTH*glyph_h*glyph_w);
+	memset(atlas->atlas, 0, CACHE_SIZE*BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
-	memset(atlas->atlas, 0, CACHE_SIZE*BDEPTH*glyph_h*glyph_w);
+	PRIV(atlas)->baseline = atlas->glyph_max_h - baseline;
-	atlas->width  = glyph_w*CACHE_SIZE/2;
+	PRIV(atlas)->scale = scale;
-	atlas->height = glyph_h*CACHE_SIZE/2;
+	PRIV(atlas)->bitmap = emalloc(BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
-
+	// FIXME: make this a square atlas
-	atlas->priv.ctx = (msdf_AllocCtx){_emalloc, _efree, NULL};
+	atlas->width  = atlas->glyph_max_w*CACHE_SIZE/4;
+	atlas->height = atlas->glyph_max_h*4;
+	atlas->size = size;
 
 	cache_init();
 
+	// preallocate all ascii characters
+	for (char c = ' '; c <= '~'; c++) {
+		if (!font_get_glyph_texture(atlas, c, NULL))
+			return -1;
+	}
+
 	return 0;
 }
 
@@ -97,6 +94,8 @@ int font_free(struct font_atlas *atlas)
 {
 	efree(atlas->atlas);
 	efree(atlas->file);
+	efree(PRIV(atlas)->bitmap);
+	efree(atlas->priv);
 	efree(atlas);
 	cache_destroy();
 	return 0;
@@ -105,80 +104,81 @@ int font_free(struct font_atlas *atlas)
 
 // FIXME: when generating the sdf I only use the height, so to not encounter memory
 //        errors height and width must be equal
-const struct font_glyph * font_get_glyph_texture(struct font_atlas *atlas, unsigned int code)
+const struct font_glyph * font_get_glyph_texture(struct font_atlas *atlas, unsigned int code, int *updated)
 {
-	const struct font_glyph *r;
+	int u = 0;
-	if ((r = cache_search(code)) != NULL)
+	if (!updated) updated = &u;
-		return r;
 
+	const struct font_glyph *r;
+	if ((r = cache_search(code)) != NULL) {
+		*updated = 0;
+		return r;
+	}
+
+	*updated = 1;
 	// generate the sdf and put it into the cache
 	// TODO: generate the whole block at once
-	int idx = stbtt_FindGlyphIndex(&atlas->priv.stb, code);
+	int idx = stbtt_FindGlyphIndex(&PRIV(atlas)->stb, code);
-	// FIXME: what happens if I change the range?
+	int x0,y0,x1,y1,gw,gh,l,off_x,off_y,adv;
-	int err;
+	stbtt_GetGlyphBitmapBoxSubpixel(
-	err = msdf_genGlyph(&atlas->priv.msdf,
+		&PRIV(atlas)->stb,
-		&atlas->priv.stb,
 		idx,
-		BORDER,
+		PRIV(atlas)->scale,
-		atlas->priv.scale,
+		PRIV(atlas)->scale,
-		2.0f/glyph_h,
+		0,0,
-		&atlas->priv.ctx);
+		&x0,&y0,
-	// msdf_genGlyph returns 0 only when there are no contours, so only for
+		&x1, &y1);
-	// whitespace and such, for those insert a zero uv map into the cache
+	gw = x1 - x0;
-	// FIXME: this is a waste of space
+	gh = y1 - y0;
-	if (!err) {
+	stbtt_GetGlyphHMetrics(&PRIV(atlas)->stb, idx, &adv, &l);
-		atlas->priv.msdf.width = 0;
+	adv *= PRIV(atlas)->scale;
-		atlas->priv.msdf.height = 0;
+	off_x = PRIV(atlas)->scale*l;
-	}
+	off_y = atlas->glyph_max_h+y0;
-
+	stbtt_MakeGlyphBitmapSubpixel(
+		&PRIV(atlas)->stb,
+		PRIV(atlas)->bitmap,
+		atlas->glyph_max_w,
+		atlas->glyph_max_h,
+		atlas->glyph_max_w,
+		PRIV(atlas)->scale,
+		PRIV(atlas)->scale,
+		0, 0, 
+		idx);
 
+	// TODO: bounds check usign atlas height
+	// TODO: clear spot area in the atlas before writing on it
 	unsigned int spot = cache_get();
-	unsigned int oy   = (glyph_h * spot) / atlas->width;
+	unsigned int oy   = ((atlas->glyph_max_w * spot) / atlas->width) * atlas->glyph_max_h;
-	unsigned int ox   = (glyph_h * spot) % atlas->height;
+	unsigned int ox   = (atlas->glyph_max_w * spot) % atlas->width;
 	unsigned int w    = atlas->width;
 
-	// sum magic shit
+	unsigned char *a = (void *)atlas->atlas;
-	struct {unsigned char r,g,b;} *a = (void *)atlas->atlas;
-	msdf_Result  *res = &atlas->priv.msdf;
-	float s  = glyph_h;
-	float tw = ((s * 0.7f) + s) / (s * 2.0f);
-	float ta = tw - 0.5f;
-	float ts = 0.5 - ta / 2;
-	float te = ts + ta;
 
-	#define NORMALIZE(x) x = x > ts ? (x > te ? 1.0f : (x-ts)/ta+0.0f) : (0.0f)
+	//printf("max:%d %d spot:%d : %d %d %d %d\n", atlas->glyph_max_w, atlas->glyph_max_h, spot, ox, oy, off_x, off_y);
 
-	for (int y = 0; y < res->height; y++) {
+	for (int y = 0; y < gh; y++) {
-	        int yPos = res->width * 3 * y;
+		for (int x = 0; x < gw; x++) {
-		for (int x = 0; x < res->width; x++) {
+			int c, r;
-
+			r = (oy+y)*w;
-			int i = yPos + (x * 3);
+			c = ox+x;
-			float r = res->rgb[i+0];
+			a[r+c] = PRIV(atlas)->bitmap[y*atlas->glyph_max_w+x];
-			float g = res->rgb[i+1];
-			float b = res->rgb[i+2];
-
-			r = (r + s) / (s * 2.0f);
-			g = (g + s) / (s * 2.0f);
-			b = (b + s) / (s * 2.0f);
-
-			NORMALIZE(r);
-			NORMALIZE(g);
-			NORMALIZE(b);
-
-			a[(oy+y)*w + (ox+x)].r = r * 255.0f; // (r > 0.5f) ? 255.0f : r * 255.0f;
-			a[(oy+y)*w + (ox+x)].g = g * 255.0f; // (g > 0.5f) ? 255.0f : g * 255.0f;
-			a[(oy+y)*w + (ox+x)].b = b * 255.0f; // (b > 0.5f) ? 255.0f : b * 255.0f;
 		}
 	}
 
+	// FIXME: get the advance
 	struct font_glyph g = {
 		.codepoint = code,
 		.u = ox,
 		.v = oy,
-		.w = res->width,
+		.w = gw,
-		.h = res->height,
+		.h = gh,
+		.x = off_x,
+		.y = off_y,
+		.a = adv,
 	};
-	return cache_insert(&g, spot);
+	const struct font_glyph *ret = cache_insert(&g, spot);
+
+	return ret;
 }
 
 
@@ -186,9 +186,8 @@ void font_dump(const struct font_atlas *atlas, const char *path)
 {
 	stbi_write_png(
 		path,
-		//atlas->width,
+		atlas->width,
-		//atlas->height,
+		atlas->height,
-		128, 128,
 		BDEPTH,
 		atlas->atlas,
 		BDEPTH*atlas->width);

text_rendering/font.h

@@ -4,33 +4,45 @@
 
 /* width and height of a glyph contain the kering advance
  * (u,v)
- *   +----------*---+ -
+ *   +-------------*---+ -
- *   |   .ii.   |   | ^
+ *   |       ^     |   | ^
+ *   |       |oy   |   | |
+ *   |       v     |   | |
+ *   |      .ii.   |   | |
  *   |     @@@@@@. |<->| |
  *   |    V@Mio@@o |adv| |
  *   |    :i.  V@V |   | |
  *   |      :oM@@M |   | |
  *   |    :@@@MM@M |   | |
  *   |    @@o  o@M |   | |
- *   |:@@.  M@M |   | |
+ *   |<->:@@.  M@M |   | |
- *   | @@@o@@@@ |   | |
+ *   |ox  @@@o@@@@ |   | |
  *   |    :M@@V:@@.|   | v
- *   +----------*---+ -
+ *   +-------------*---+ -
  *   |<------------->|
  *           w
  */
+// TODO: the advance isn't unique for every pair of characters
 struct font_glyph {
 	unsigned int codepoint;
-	unsigned int u, v, w, h;
+	unsigned int u, v, w, h, a, x, y;
+};
+
+struct font_atlas {
+	unsigned int width, height;
+	unsigned char *atlas;
+	unsigned int glyph_max_w, glyph_max_h;
+	int size;
+	int file_size;
+	char *file;
+	void *priv;
 };
 
 
-struct font_atlas;
-
 struct font_atlas * font_init(void);
-int font_load(struct font_atlas *atlas, const char *path);
+int font_load(struct font_atlas *atlas, const char *path, int size);
 int font_free(struct font_atlas *atlas);
-const struct font_glyph * font_get_glyph_texture(struct font_atlas *atlas, unsigned int code);
+const struct font_glyph * font_get_glyph_texture(struct font_atlas *atlas, unsigned int code, int *updated);
 void font_dump(const struct font_atlas *atlas, const char *path);
 
 #endif

text_rendering/font_fragshader.glsl

@@ -0,0 +1,15 @@
+#version 330 core
+
+// viewsize.x = viewport width in pixels; viewsize.y = viewport height in pixels
+uniform ivec2 viewsize;
+uniform ivec2 texturesize;
+
+// texture uv coordinate in texture space
+in vec2 uv;
+uniform sampler2D ts;
+
+void main()
+{
+	//gl_FragColor = vec4(1.0f,0.0f,0.0f,1.0f);
+	gl_FragColor = texture(ts, uv);
+}

text_rendering/font_vertshader.glsl

@@ -0,0 +1,26 @@
+#version 330 core
+
+// viewsize.x = viewport width in pixels; viewsize.y = viewport height in pixels
+uniform ivec2 viewsize;
+uniform ivec2 texturesize;
+
+// both position and and uv are in pixels, they where converted to floats when 
+// passed to the shader
+layout(location = 0) in vec2 position;
+layout(location = 1) in vec2 txcoord;
+
+out vec2 uv;
+
+void main()
+{
+	// matrix to change from image coordinates to opengl coordinates
+	mat2 transform = mat2(vec2(0.0f, -1.0f), vec2(1.0f, 0.0f));
+	vec2 v = vec2(float(viewsize.x), float(viewsize.y));
+	vec2 h = v/2.0f;
+	vec2 p = ((position-h)/ h);
+
+	vec4 pos = vec4(p.x, p.y, 0.0f, 1.0f);
+
+	gl_Position = pos;
+	uv = vec2(txcoord.x / float(texturesize.x), (float(texturesize.y) - txcoord.y) / float(texturesize.y));
+}

text_rendering/main.c

@@ -1,33 +1,51 @@
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_events.h>
+#include <SDL2/SDL_video.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <grapheme.h>
 
-#include "cache.h"
+#include "ren.h"
-#include "font.h"
 #include "util.h"
 
 
 int main(void)
 {
-	int err;
+	SDL_Window *win = SDL_CreateWindow(
-	struct font_atlas *at = font_init();
+		"test render",
-	err = font_load(at, "./monospace.ttf");
+		SDL_WINDOWPOS_UNDEFINED,
-	ERROR(err, -1, printf("failed to load font\n"));
+		SDL_WINDOWPOS_UNDEFINED,
-
+		500,
-	const char *s = "ciao mamma";
+		500,
-	const struct font_glyph *g;
+		SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
-	size_t ret, off;
+	if (ren_init(win)) {
-	uint_least32_t cp;
+		printf("renderer init error: %s\n", ren_strerror());
-	for (off = 0; (ret = grapheme_decode_utf8(s+off, SIZE_MAX, &cp)) > 0 && cp != 0; off += ret) {
+		return 1;
-		printf("%.*s (%d) -> %d\n", (int)ret, s+off, (int)ret, cp);
-		g = font_get_glyph_texture(at, cp);
-		if (!g)
-			printf("g is NULL\n");
 	}
 
-	font_dump(at, "./atlas.png");
+	ren_render_text("ciao mamma", 0, 0, 100, 100, 12);
+	SDL_GL_SwapWindow(win);
 
-	font_free(at);
+	SDL_Event e;
+	while(1) {
+		SDL_WaitEvent(&e);
+		if (e.type == SDL_QUIT)
+			break;
+		if (e.type == SDL_WINDOWEVENT) {
+			switch (e.window.event) {
+			case SDL_WINDOWEVENT_RESIZED:
+			case SDL_WINDOWEVENT_SIZE_CHANGED:
+				ren_update_viewport(e.window.data1, e.window.data2);
+			case SDL_WINDOWEVENT_EXPOSED:
+				ren_render_text("ciao mamma", 0, 0, 100, 100, 12);
+				SDL_GL_SwapWindow(win);
+				break;
+			default: break;
+			}
+		}
+	}
 
+	ren_free();
+	SDL_DestroyWindow(win);
+	SDL_Quit();
 	return 0;
 }

text_rendering/msdf_c/.gitignore

@@ -1,3 +0,0 @@
-build
-.vscode
-.DS_Store

text_rendering/msdf_c/Readme.md

@@ -1,27 +0,0 @@
-# msdf_c 0.1
-A pure C99 multi-channel signed distance field generator.  Handles MSDF bitmap
-Generation from given ttf/otf font (outlines).
-Single Header STB-style library
-
----
-
-[This library is my take on improving msdf-c with some fixes and improving its API](https://github.com/solenum/msdf-c)
-
-[Based on the C++ implementation by Viktor Chlumský.](https://github.com/Chlumsky/msdfgen)
-
-~~~
-// example fragment shader
-// scale is render_width/glyph_width
-// render_width being the width of each rendered glyph
-float median(float r, float g, float b) {
-    return max(min(r, g), min(max(r, g), b));
-}
-
-void main()
-{
-  vec3 sample = texture(u_texture, uv).rgb;
-  float dist = scale * (median(sample.r, sample.g, sample.b) - 0.5);
-  float o = clamp(dist + 0.5, 0.0, 1.0);
-  color = vec4(vec3(1.0), o);
-}
-~~~

text_rendering/msdf_c/msdf.c

@@ -1,4 +0,0 @@
-#define STB_TRUETYPE_IMPLEMENTATION
-#include "stb_truetype.h"
-#define MSDF_IMPLEMENTATION
-#include "msdf.h"

text_rendering/msdf_c/sample/fonts/RobotoLicense.txt

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

text_rendering/msdf_c/sample/sample.c

@@ -1,210 +0,0 @@
-//#include "svpng.h"
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#include "stb_image_write.h"
-#define STB_TRUETYPE_IMPLEMENTATION
-#include "../stb_truetype.h"
-#define MSDF_IMPLEMENTATION
-#include "../msdf.h"
-
-#include "stdio.h"
-
-
-#ifndef SAMPLE_ROOT
-#define SAMPLE_ROOT ""
-#endif
-
-typedef struct Range {
-    void* content;
-    size_t size;
-} Range;
-
-Range g_fileRead(const char* fileName) {
-    Range range = {NULL, 0};
-
-    FILE* fileHandle = fopen(fileName, "rb");
-    if (fileHandle == NULL) {
-        assert(!"File not fount");
-        return range;
-    }
-
-    fseek(fileHandle, 0, SEEK_END); // seek to end of file
-    size_t size = ftell(fileHandle); // get current file pointer
-    fseek(fileHandle, 0, SEEK_SET); // seek back to beginning of file
-
-    if (size == 0) {
-        assert(!"File size zero");
-        return range;
-    }
-
-    void* mem = malloc(size);
-    size_t readSize = fread(mem, 1, size, fileHandle);
-    if (readSize == size) {
-        range.content = mem;
-        range.size = size;
-    } else {
-        free(mem);
-    }
-    fclose(fileHandle);
-    return range;
-}
-
-static void* g_alloc(size_t size, void* ctx) {
-    return malloc(size);
-}
-
-static void g_free(void* ptr, void* ctx) {
-    return free(ptr);
-}
-
-float g_min(float a, float b) {
-    return a > b ? b : a;
-}
-
-float g_max(float a, float b) {
-    return a > b ? a : b;
-}
-
-float g_clamp(float val, float min, float max) {
-    return g_min(g_max(val, min), max);
-}
-
-float g_median(float r, float g, float b) {
-    return g_max(g_min(r, g), g_min(g_max(r, g), b));
-}
-
-float g_map(float min, float max, float v) {
-    return (v - min) / (max - min);
-}
-
-int main() {
-    stbtt_fontinfo stbttInfo;
-
-    Range fontFile = g_fileRead("./fonts/Roboto-Regular.ttf");
-
-    if (fontFile.content == NULL) {
-        assert(!"could not load font from disk");
-        return 1;
-    }
-
-    if (!stbtt_InitFont(&stbttInfo, fontFile.content, stbtt_GetFontOffsetForIndex(fontFile.content, 0))) {
-        assert(!"Couldn't parse font");
-		return 1;
-    }
-
-
-    int ascent, descent;
-    stbtt_GetFontVMetrics(&stbttInfo, &ascent, &descent, 0);
-
-    int borderSize = 4;
-    int genSize = 32+borderSize;
-    float genScale = stbtt_ScaleForPixelHeight(&stbttInfo, genSize);
-
-   // int glyph = 0x00e8; // è
-	int glyph = 0x069D;
-
-    int glyphIdx = stbtt_FindGlyphIndex(&stbttInfo, glyph);
-
-    msdf_AllocCtx allocCtx = {g_alloc, g_free, NULL};
-
-
-	printf("bruh\n");
-
-    msdf_Result result;
-    int success = msdf_genGlyph(&result, &stbttInfo, glyphIdx, borderSize, genScale, 2.0f / genSize, &allocCtx);
-
-    if (success == 0) {
-        assert(!"Failed to generate msdf glyph");
-        return 1;
-    }
-	printf("bruh\n");
-
-//    FILE* fp = fopen(SAMPLE_ROOT "/sdf.png", "wb");
-
-    uint8_t* pixels = malloc(sizeof(uint8_t) * result.width * result.height * 3);
-    float scale = genSize;
-    float maxValue = 1.0 * (scale);
-    float transistionWidth = ((((((float) genSize) * 0.7f) + scale) / (scale * 2.0f)));
-    float transistionAbs = (transistionWidth - 0.5);
-    float transistStart = 0.5 - transistionAbs / 2;
-    float transistEnd = transistStart + transistionAbs;
-   
-    //float ff = expf(0.01);
-    for (int y = 0; y < result.height; y++) {
-        int yPos = result.width * 3 * y;
-        uint8_t* pixelRow = pixels + (y * result.width * 3);
-        for (int x = 0; x < result.width; x++) {
-            int indexSdf = yPos + (x * 3);
-            float r = result.rgb[indexSdf + 0];
-            float g = result.rgb[indexSdf + 1];
-            float b = result.rgb[indexSdf + 2];
-
-
-            r = ((((r) + scale) / (scale * 2.0f)));
-            g = ((((g) + scale) / (scale * 2.0f)));
-            b = ((((b) + scale) / (scale * 2.0f)));
-
-            if (r > transistStart) {
-                if (r > (transistEnd)) {
-                    r = 1.0f;
-                } else {
-                    r = 0.0f + (r - transistStart) / (transistionAbs);
-                }
-            } else {
-                r = 0.0f;
-            }
-            if (g > transistStart) {
-                if (g > (transistEnd)) {
-                    g = 1.0f;
-                } else {
-                    g = 0.0f + (g - transistStart) / (transistionAbs);
-                }
-            } else {
-                g = 0.0f;
-            }
-            if (b > transistStart) {
-                if (b > (transistEnd)) {
-                    b = 1.0f;
-                } else {
-                    b = 0.0f + (b - transistStart) / (transistionAbs);
-                }
-            } else {
-                b = 0.0f;
-            }
-
-            pixelRow[x * 3 + 0] = r * 255.0f; // (r > 0.5f) ? 255.0f : r * 255.0f;
-            pixelRow[x * 3 + 1] = g * 255.0f; // (g > 0.5f) ? 255.0f : g * 255.0f;
-            pixelRow[x * 3 + 2] = b * 255.0f; // (b > 0.5f) ? 255.0f : b * 255.0f;
-        }
-    }
-//	printf("bruh\n");
-//
-//    svpng(fp, result.width, result.height, pixels, 0);
-	stbi_write_png("./sdf.png", result.width, result.height, 3, pixels, 3*result.width);
-//    fclose(fp);
-
-    // apply sdf
-//
-//    FILE* finalImage = fopen(SAMPLE_ROOT "/final.png", "wb");
-//
-//    uint8_t* rgbaFinal = malloc(sizeof(uint8_t) * result.width * result.height * 4);
-//
-//    for (int y = 0; y < result.height; y++) {
-//        uint8_t* pixelRow = pixels + (y * result.width * 3);
-//        uint8_t* rgbaFinalRow = rgbaFinal + (y * result.width * 4);
-//        for (int x = 0; x < result.width; x++) {
-//            float r = ((float)pixelRow[x * 3 + 0]) / 255.0f;// = r * 255.0f; // (r > 0.5f) ? 255.0f : r * 255.0f;
-//            float g = ((float)pixelRow[x * 3 + 1]) / 255.0f;// = g * 255.0f; // (g > 0.5f) ? 255.0f : g * 255.0f;
-//            float b = ((float)pixelRow[x * 3 + 2]) / 255.0f;// = b * 255.0f; // (b > 0.5f) ? 255.0f : b * 255.0f;
-//            float dist = g_median(r, g, b);
-//            float opacity = g_clamp(dist - 0.5f, 0, 1) * 2.0f;
-//            rgbaFinalRow[x * 4 + 0] = 0;//255.0f;
-//            rgbaFinalRow[x * 4 + 1] = 0;//255.0f;
-//            rgbaFinalRow[x * 4 + 2] = 0;//255.0f;
-//            rgbaFinalRow[x * 4 + 3] = opacity * 255.0f;
-//
-//        }
-//    }
-//    svpng(finalImage, result.width, result.height, rgbaFinal, 1);
-//    fclose(finalImage);
-    return 0;
-}

text_rendering/msdf_c/sample/svpng.h

@@ -1,110 +0,0 @@
-/*
-Copyright (C) 2017 Milo Yip. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of pngout nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/*! \file
-    \brief      svpng() is a minimalistic C function for saving RGB/RGBA image into uncompressed PNG.
-    \author     Milo Yip
-    \version    0.1.1
-    \copyright  MIT license
-    \sa         http://github.com/miloyip/svpng
-*/
-
-#ifndef SVPNG_INC_
-#define SVPNG_INC_
-
-/*! \def SVPNG_LINKAGE
-    \brief User customizable linkage for svpng() function.
-    By default this macro is empty.
-    User may define this macro as static for static linkage, 
-    and/or inline in C99/C++, etc.
-*/
-#ifndef SVPNG_LINKAGE
-#define SVPNG_LINKAGE
-#endif
-
-/*! \def SVPNG_OUTPUT
-    \brief User customizable output stream.
-    By default, it uses C file descriptor and fputc() to output bytes.
-    In C++, for example, user may use std::ostream or std::vector instead.
-*/
-#ifndef SVPNG_OUTPUT
-#include <stdio.h>
-#define SVPNG_OUTPUT FILE* fp
-#endif
-
-/*! \def SVPNG_PUT
-    \brief Write a byte
-*/
-#ifndef SVPNG_PUT
-#define SVPNG_PUT(u) fputc(u, fp)
-#endif
-
-
-/*!
-    \brief Save a RGB/RGBA image in PNG format.
-    \param SVPNG_OUTPUT Output stream (by default using file descriptor).
-    \param w Width of the image. (<16383)
-    \param h Height of the image.
-    \param img Image pixel data in 24-bit RGB or 32-bit RGBA format.
-    \param alpha Whether the image contains alpha channel.
-*/
-SVPNG_LINKAGE void svpng(SVPNG_OUTPUT, unsigned w, unsigned h, const unsigned char* img, int alpha) {
-    static const unsigned t[] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, 
-    /* CRC32 Table */    0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };
-    unsigned a = 1, b = 0, c, p = w * (alpha ? 4 : 3) + 1, x, y, i;   /* ADLER-a, ADLER-b, CRC, pitch */
-#define SVPNG_U8A(ua, l) for (i = 0; i < l; i++) SVPNG_PUT((ua)[i]);
-#define SVPNG_U32(u) do { SVPNG_PUT((u) >> 24); SVPNG_PUT(((u) >> 16) & 255); SVPNG_PUT(((u) >> 8) & 255); SVPNG_PUT((u) & 255); } while(0)
-#define SVPNG_U8C(u) do { SVPNG_PUT(u); c ^= (u); c = (c >> 4) ^ t[c & 15]; c = (c >> 4) ^ t[c & 15]; } while(0)
-#define SVPNG_U8AC(ua, l) for (i = 0; i < l; i++) SVPNG_U8C((ua)[i])
-#define SVPNG_U16LC(u) do { SVPNG_U8C((u) & 255); SVPNG_U8C(((u) >> 8) & 255); } while(0)
-#define SVPNG_U32C(u) do { SVPNG_U8C((u) >> 24); SVPNG_U8C(((u) >> 16) & 255); SVPNG_U8C(((u) >> 8) & 255); SVPNG_U8C((u) & 255); } while(0)
-#define SVPNG_U8ADLER(u) do { SVPNG_U8C(u); a = (a + (u)) % 65521; b = (b + a) % 65521; } while(0)
-#define SVPNG_BEGIN(s, l) do { SVPNG_U32(l); c = ~0U; SVPNG_U8AC(s, 4); } while(0)
-#define SVPNG_END() SVPNG_U32(~c)
-    SVPNG_U8A("\x89PNG\r\n\32\n", 8);           /* Magic */
-    SVPNG_BEGIN("IHDR", 13);                    /* IHDR chunk { */
-    SVPNG_U32C(w); SVPNG_U32C(h);               /*   Width & Height (8 bytes) */
-    SVPNG_U8C(8); SVPNG_U8C(alpha ? 6 : 2);     /*   Depth=8, Color=True color with/without alpha (2 bytes) */
-    SVPNG_U8AC("\0\0\0", 3);                    /*   Compression=Deflate, Filter=No, Interlace=No (3 bytes) */
-    SVPNG_END();                                /* } */
-    SVPNG_BEGIN("IDAT", 2 + h * (5 + p) + 4);   /* IDAT chunk { */
-    SVPNG_U8AC("\x78\1", 2);                    /*   Deflate block begin (2 bytes) */
-    for (y = 0; y < h; y++) {                   /*   Each horizontal line makes a block for simplicity */
-        SVPNG_U8C(y == h - 1);                  /*   1 for the last block, 0 for others (1 byte) */
-        SVPNG_U16LC(p); SVPNG_U16LC(~p);        /*   Size of block in little endian and its 1's complement (4 bytes) */
-        SVPNG_U8ADLER(0);                       /*   No filter prefix (1 byte) */
-        for (x = 0; x < p - 1; x++, img++)
-            SVPNG_U8ADLER(*img);                /*   Image pixel data */
-    }
-    SVPNG_U32C((b << 16) | a);                  /*   Deflate block end with adler (4 bytes) */
-    SVPNG_END();                                /* } */
-    SVPNG_BEGIN("IEND", 0); SVPNG_END();        /* IEND chunk {} */
-}
-
-#endif /* SVPNG_INC_ */

text_rendering/ren.c

@@ -1,53 +1,506 @@
 #include <SDL2/SDL.h>
 #include <GL/glew.h>
 #include <SDL2/SDL_opengl.h>
+#include <SDL2/SDL_video.h>
+#include <grapheme.h>
+#include <stdio.h>
+
+#include "util.h"
+#include "font.h"
+#include "ren.h"
 
 
-#define GLSL_VERT_SHADER "vertex.glsl"
+#define GLERR()  {int a = glGetError(); if (a != GL_NO_ERROR) printf("(%s:%d %s) glError: 0x%x %s\n", __FILE__, __LINE__, __func__, a, glerr[a]);}
-#define GLSL_FRAG_SHADER "fragment.glsl"
+#define GL(f) f; GLERR()
-#define PACKED __attribute__((packed))
 
 
-struct {
+enum REN_ERR {
-	SDL_Window *w;
+	REN_SUCCESS = 0,
-	SDL_GLContext *gl;
+	REN_ERRNO,
-	GLuint gl_vertbuffer;
+	REN_INVAL,
-	GLuint gl_program;
+	REN_VERTEX,
-	GLuint font_texture;
+	REN_FRAGMENT,
-} ren = {0};
+	REN_PROGRAM,
-
+	REN_COMPILE,
-
+	REN_LINK,
-typedef struct PACKED {
+	REN_TEXTURE,
-	union { GLint x, u; };
+	REN_CONTEXT,
-	union { GLint y, v; };
+	REN_GLEW,
-} vec2_i;
+	REN_FONT,
-
+	REN_BUFFER,
-typedef struct PACKED {
+	REN_UNIFORM,
-	union { GLint x, r; };
-	union { GLint y, g; };
-	union { GLint z, b; };
-	union { GLint w, a; };
-} vec4_i;
-
-// textured vertex
-struct PACKED v_text {
-	vec2_i pos;
-	vec2_i uv;
 };
 
-// colored vertex
+
-struct PACKED v_col {
+// TODO: make a macro for enum-associated string arrays
-	vec2_i pos;
+const char * ren_err_msg[] = {
-	vec2_i col;
+	[REN_SUCCESS]  = "Success",
+	[REN_ERRNO]    = "Look at errno",
+	[REN_INVAL]    = "Invalid or NULL arguments",
+	[REN_VERTEX]   = "Failed to create opengl vertex shader",
+	[REN_FRAGMENT] = "Failed to create opengl fragment shader",
+	[REN_PROGRAM]  = "Failed to create opengl program",
+	[REN_COMPILE]  = "Failed to compile shaders",
+	[REN_LINK]     = "Failed to link shaders",
+	[REN_TEXTURE]  = "Failed to create texture",
+	[REN_CONTEXT]  = "Failed to create SDL OpenGL context",
+	[REN_GLEW]     = "GLEW Error",
+	[REN_FONT]     = "Font Error",
+	[REN_BUFFER]   = "Failed to create opengl buffer",
+	[REN_UNIFORM]  = "Failed to get uniform location",
 };
 
 
+#define ELEM(x...) [x] = #x,
+const char *glerr[] = {
+	ELEM(GL_INVALID_ENUM)
+	ELEM(GL_INVALID_VALUE)
+	ELEM(GL_INVALID_OPERATION)
+	ELEM(GL_OUT_OF_MEMORY)
+};
+#undef ELEM
+
+
 // different stacks
-#define _STACK_NAME vtstack
-#define _STACK_TYPE struct v_text
-#include "stack.h"
-#undef _STACK_NAME
-#undef _STACK_TYPE
-#define _STACK_NAME vcstack
-#define _STACK_TYPE struct v_col
 #include "stack.h"
+STACK_DECL(vtstack, struct v_text)
+STACK_DECL(vcstack, struct v_col)
+
+
+struct {
+	SDL_GLContext *gl;
+	struct font_atlas *font;
+	GLuint font_texture;
+	GLuint font_prog;
+	GLuint box_prog;
+	GLuint font_buffer;
+	GLint  viewsize_loc;
+	GLint texturesize_loc;
+	struct vtstack font_stack;
+	struct vcstack box_stack;
+	int width, height;
+	int s_x, s_y, s_w, s_h;
+} ren = {0};
+
+
+static int ren_errno;
+
+
+// print shader compilation errors
+static int shader_compile_error(GLuint shader)
+{
+	GLint status;
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+	if (status != GL_FALSE)
+		return 0;
+
+	GLint log_length;
+	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
+
+	GLchar *log_str = emalloc((log_length + 1)*sizeof(GLchar));
+	glGetShaderInfoLog(shader, log_length, NULL, log_str);
+
+	const char *shader_type_str = NULL;
+	GLint shader_type;
+	glGetShaderiv(shader, GL_SHADER_TYPE, &shader_type);
+	switch(shader_type) {
+	case GL_VERTEX_SHADER:   shader_type_str = "vertex";   break;
+	case GL_GEOMETRY_SHADER: shader_type_str = "geometry"; break;
+	case GL_FRAGMENT_SHADER: shader_type_str = "fragment"; break;
+	}
+
+	fprintf(stderr, "Compile failure in %s shader:\n%s\n", shader_type_str, log_str);
+	efree(log_str);
+	return -1;
+}
+
+
+// print shader link errors
+static int shader_link_error(GLuint prog)
+{
+	GLint status;
+	glGetProgramiv (prog, GL_LINK_STATUS, &status);
+	if (status != GL_FALSE)
+		return 0;
+
+	GLint log_length;
+	glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &log_length);
+
+	GLchar *log_str = emalloc((log_length + 1)*sizeof(GLchar));
+	glGetProgramInfoLog(prog, log_length, NULL, log_str);
+	fprintf(stderr, "Linker failure: %s\n", log_str);
+	efree(log_str);
+
+	return -1;
+}
+
+
+#define REN_RET(a,b) {ren_errno = b; return a;}
+static GLuint shader_compile(const char *shader, GLuint type)
+{
+	GLuint s;
+	// initialize the vertex shader and get the corresponding id
+	s = GL(glCreateShader(type))
+	if (!s) REN_RET(0, REN_VERTEX)
+	// get the shader into opengl
+	GL(glShaderSource(s, 1, &shader, NULL))
+	GL(glCompileShader(s))
+	if (shader_compile_error(s))
+		REN_RET(0, REN_COMPILE)
+	return s;
+}
+
+
+const char * ren_strerror(void)
+{
+	return ren_err_msg[ren_errno % (sizeof(ren_err_msg)/sizeof(char *))];
+}
+
+
+// compile a vertex shader (vs_path) and a fragment shader (fs_path) into an opengl
+// program and return it's index
+static GLuint ren_compile_program(const char *vs_path, const char *fs_path)
+{
+	GLuint gl_vertshader, gl_fragshader, prog;
+
+	if (!vs_path || !fs_path)
+		REN_RET(0, REN_INVAL)
+
+	char *str = NULL;
+
+	dump_file(vs_path, &str, NULL);
+	if (!str) REN_RET(0, REN_ERRNO)
+	gl_vertshader = shader_compile(str, GL_VERTEX_SHADER);
+	efree(str);
+	if (!gl_vertshader)
+		return 0;
+
+	dump_file(fs_path, &str, NULL);
+	if (!str) REN_RET(0, REN_ERRNO)
+	gl_fragshader = shader_compile(str, GL_FRAGMENT_SHADER);
+	efree(str);
+	if (!gl_fragshader)
+		return 0;
+
+
+	// create the main program object, it is an amalgamation of all shaders
+	prog = GL(glCreateProgram())
+	if (!prog) REN_RET(0, REN_PROGRAM)
+
+	// attach the shaders to the program (set which shaders are present)
+	GL(glAttachShader(prog, gl_vertshader))
+	GL(glAttachShader(prog, gl_fragshader))
+	// then link the program (basically the linking stage of the program)
+	GL(glLinkProgram(prog))
+	if (shader_link_error(prog))
+		REN_RET(0, REN_LINK)
+
+	// after linking the shaders can be detached and the source freed from
+	// memory since the program is ready to use
+	GL(glDetachShader(prog, gl_vertshader))
+	GL(glDetachShader(prog, gl_fragshader))
+
+	return prog;
+}
+
+
+static GLuint ren_texturergb_2d(const char *buf, int w, int h, int upscale, int downscale)
+{
+	GLuint t;
+
+	if (!buf || w <= 0 || h <= 0)
+		REN_RET(0, REN_INVAL)
+
+	GL(glGenTextures(1, &t))
+	if (!t) REN_RET(0, REN_TEXTURE)
+
+	GL(glBindTexture(GL_TEXTURE_2D, t))
+	GL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, buf))
+
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, downscale))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, upscale))
+
+	return t;
+}
+
+
+static GLuint ren_texturergba_2d(const char *buf, int w, int h, int upscale, int downscale)
+{
+	GLuint t;
+
+	if (!buf || w <= 0 || h <= 0)
+		REN_RET(0, REN_INVAL)
+
+	GL(glGenTextures(1, &t))
+	if (!t) REN_RET(0, REN_TEXTURE)
+
+	GL(glBindTexture(GL_TEXTURE_2D, t))
+	GL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf))
+
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, downscale))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, upscale))
+
+	return t;
+}
+
+
+static GLuint ren_texturer_2d(const char *buf, int w, int h, int upscale, int downscale)
+{
+	GLuint t;
+
+	if (!buf || w <= 0 || h <= 0)
+		REN_RET(0, REN_INVAL)
+
+	GL(glGenTextures(1, &t))
+	if (!t) REN_RET(0, REN_TEXTURE)
+
+	GL(glBindTexture(GL_TEXTURE_2D, t))
+	GL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, buf))
+
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, downscale))
+	GL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, upscale))
+
+	return t;
+}
+
+
+
+// FIXME: update only the newly generated character instead of the whole texture
+static int update_font_texture(void)
+{
+	GL(glTexSubImage2D(
+		ren.font_texture,
+		0, 0, 0,
+		ren.font->width,
+		ren.font->height,
+		GL_R,
+		GL_UNSIGNED_BYTE,
+		ren.font->atlas))
+	font_dump(ren.font, "./atlas.png");
+	return 0;
+}
+
+
+// TODO: push window size uniforms
+int ren_init(SDL_Window *w)
+{
+	if (!w)
+		REN_RET(-1, REN_INVAL)
+	ren.gl = SDL_GL_CreateContext(w);
+	if (!ren.gl)
+		REN_RET(-1, REN_CONTEXT)
+	
+	// select some features
+	GL(glEnable(GL_BLEND))
+	GL(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA))
+	GL(glDisable(GL_CULL_FACE))
+	GL(glDisable(GL_DEPTH_TEST))
+	GL(glEnable(GL_SCISSOR_TEST))
+	GL(glEnable(GL_TEXTURE_2D))
+
+	GLenum glew_err = glewInit();
+	if (glew_err != GLEW_OK)
+		REN_RET(glew_err, REN_GLEW);
+
+	ren.font = font_init();
+	if (!ren.font) REN_RET(-1, REN_FONT) 
+	if (font_load(ren.font, FONT_PATH, 20)) REN_RET(-1, REN_FONT)
+	font_dump(ren.font, "./atlas.png");
+
+	ren.font_texture = ren_texturer_2d(
+		(const char *)ren.font->atlas,
+		ren.font->width,
+		ren.font->height,
+		GL_LINEAR, GL_LINEAR);
+	if (!ren.font_texture) return -1;
+
+	ren.font_prog = ren_compile_program(FONT_VERSHADER, FONT_FRAGSHADER);
+	if (!ren.font_prog) return -1;
+
+	ren.font_stack = vtstack_init();
+	ren.box_stack  = vcstack_init(); 
+
+	// generate the font buffer object 
+	GL(glGenBuffers(1, &ren.font_buffer))
+	if (!ren.font_buffer) REN_RET(-1, REN_BUFFER)
+
+	// create the uniforms
+	ren.viewsize_loc = GL(glGetUniformLocation(ren.font_prog, "viewsize"))
+	if (ren.viewsize_loc == -1) REN_RET(-1, REN_UNIFORM)
+	ren.texturesize_loc = GL(glGetUniformLocation(ren.font_prog, "texturesize"))
+	if (ren.texturesize_loc == -1) REN_RET(-1, REN_UNIFORM)
+
+	int width, height;
+	SDL_GetWindowSize(w, &width, &height);
+	ren_update_viewport(width, height);
+	GL(glClearColor(0.3f, 0.3f, 0.3f, 0.f))
+	GL(glClear(GL_COLOR_BUFFER_BIT))
+
+	return 0;
+}
+
+
+static int ren_draw_font_stack(void)
+{
+	GL(glUseProgram(ren.font_prog))
+	GL(glBindBuffer(GL_ARRAY_BUFFER, ren.font_buffer))
+
+	GL(glViewport(0, 0, ren.width, ren.height))
+	GL(glScissor(ren.s_x, ren.s_y, ren.s_w, ren.s_h))
+	GL(glUniform2i(ren.viewsize_loc, ren.width, ren.height))
+	GL(glUniform2i(ren.texturesize_loc, ren.font->width, ren.font->height))
+
+	GL(glEnableVertexAttribArray(REN_VERTEX_IDX))
+	GL(glEnableVertexAttribArray(REN_UV_IDX))
+	// when passing ints to glVertexAttribPointer they are automatically 
+	// converted to floats
+	GL(glVertexAttribPointer(
+		REN_VERTEX_IDX,
+		2,
+		GL_INT,
+		GL_FALSE,
+		sizeof(struct v_text),
+		0))
+	GL(glVertexAttribPointer(
+		REN_UV_IDX,
+		2,
+		GL_INT,
+		GL_FALSE,
+		sizeof(struct v_text),
+		(void*)sizeof(vec2_i)))
+	// TODO: implement size and damage tracking on stacks
+	GL(glBufferData(
+		GL_ARRAY_BUFFER,
+		ren.font_stack.idx*sizeof(struct v_text),
+		ren.font_stack.items,
+		GL_DYNAMIC_DRAW))
+	GL(glDrawArrays(GL_TRIANGLES, 0, ren.font_stack.idx))
+
+	GL(glDisableVertexAttribArray(REN_VERTEX_IDX))
+	GL(glDisableVertexAttribArray(REN_UV_IDX))
+	GL(glBindBuffer(GL_ARRAY_BUFFER, 0))
+	GL(glUseProgram(0))
+	return 0;
+}
+
+
+int ren_update_viewport(int w, int h)
+{
+	ren.width = w;
+	ren.height = h;
+	return 0;
+}
+
+
+// TODO: add a scissor array in order to do less render calls
+int ren_set_scissor(int x, int y, int w, int h)
+{
+	ren.s_x = x;
+	ren.s_y = y;
+	ren.s_w = w;
+	ren.s_h = h;
+	return 0;
+}
+
+
+
+// TODO: implement font size
+int ren_render_text(const char *str, int x, int y, int w, int h, int size)
+{
+	// x4,y4        x3,y3
+	// +-------------+
+	// |(x,y)       /|
+	// |          /  |
+	// |   2    /    |
+	// |      /      |
+	// |    /        |
+	// |  /     1    |
+	// |/            |
+	// +-------------+
+	// x1,y1        x2,y2
+
+	const struct font_glyph *g;
+	struct font_glyph c;
+	size_t ret, off;
+	uint_least32_t cp;
+	int updated, gx = x, gy = y;
+	struct v_text v;
+	for (off = 0; (ret = grapheme_decode_utf8(str+off, SIZE_MAX, &cp)) > 0 && cp != 0; off += ret) {
+		g = font_get_glyph_texture(ren.font, cp, &updated);
+		if (!g) REN_RET(-1, REN_FONT);
+		if (updated) {
+			if (update_font_texture())
+				REN_RET(-1, REN_TEXTURE);
+		}
+		c = *g;
+		printf("g: u=%d v=%d w=%d h=%d a=%d x=%d y=%d\n", c.u, c.v, c.w, c.h, c.a, c.x, c.y);
+
+		// x1,y1
+		v = (struct v_text){
+			.pos = { .x = gx+c.x, .y = gy+c.y+c.h   },
+			.uv  = { .u = c.u,    .v = c.v+c.h },
+		};
+		vtstack_push(&ren.font_stack, &v);
+		// x2,y2
+		v = (struct v_text){
+			.pos = { .x = gx+c.x+c.w, .y = gy+c.y+c.h   },
+			.uv  = { .u = c.u+c.w,    .v = c.v+c.h },
+		};
+		vtstack_push(&ren.font_stack, &v);
+		// x3,y3
+		v = (struct v_text){
+			.pos = { .x = gx+c.x+c.w, .y = gy+c.y   },
+			.uv  = { .u = c.u+c.w,    .v = c.v },
+		};
+		vtstack_push(&ren.font_stack, &v);
+		vtstack_push(&ren.font_stack, &v);
+		// x4,y4
+		v = (struct v_text){
+			.pos = { .x = gx+c.x, .y = gy+c.y   },
+			.uv  = { .u = c.u,    .v = c.v },
+		};
+		vtstack_push(&ren.font_stack, &v);
+		// x1,y1
+		v = (struct v_text){
+			.pos = { .x = gx+c.x, .y = gy+c.y+c.h   },
+			.uv  = { .u = c.u,    .v = c.v+c.h },
+		};
+		vtstack_push(&ren.font_stack, &v);
+
+		// TODO: possible kerning needs to be applied here
+		// FIXME: advance is too large
+		//gx += c.w + c.a;
+		gx += c.w + c.x + 1;
+		if (cp == '\n')
+			gy += ren.font->glyph_max_h; 
+			// TODO: encode and/or store line height
+	}
+
+	// FIXME: here we are doing one draw call for string of text which is 
+	// inefficient but is simpler and allows for individual scissors
+	ren_set_scissor(x, y, w, h);
+	ren_draw_font_stack();
+	vtstack_clear(&ren.font_stack);
+
+	return 0;
+}
+
+
+int ren_free(void)
+{
+	GL(glUseProgram(0))
+	GL(glBindBuffer(GL_ARRAY_BUFFER, 0))
+	GL(glDeleteTextures(1, &ren.font_texture))
+	GL(glDeleteBuffers(1, &ren.font_buffer))
+	SDL_GL_DeleteContext(ren.gl);
+	vtstack_free(&ren.font_stack);
+	vcstack_free(&ren.box_stack);
+	font_free(ren.font);
+	return 0;
+}

text_rendering/ren.h

@@ -0,0 +1,47 @@
+#ifndef _RENDERER_H
+#define _RENDERER_H
+
+#include <SDL2/SDL.h>
+
+
+#define FONT_PATH "./monospace.ttf"
+#define FONT_VERSHADER "./font_vertshader.glsl"
+#define FONT_FRAGSHADER "./font_fragshader.glsl"
+#define REN_VERTEX_IDX 0
+#define REN_UV_IDX     1
+#define REN_COLOR_IDX  2
+
+
+typedef struct {
+	union { int x, u; };
+	union { int y, v; };
+} vec2_i;
+
+typedef struct {
+	union { int x, r; };
+	union { int y, g; };
+	union { int z, b; };
+	union { int w, a; };
+} vec4_i;
+
+// textured vertex
+struct v_text {
+	vec2_i pos;
+	vec2_i uv;
+};
+
+// colored vertex
+struct v_col {
+	vec2_i pos;
+	vec2_i col;
+};
+
+
+int ren_init(SDL_Window *sdl_window);
+int ren_free(void);
+const char * ren_strerror(void);
+int ren_update_viewport(int w, int h);
+int ren_render_text(const char *str, int x, int y, int w, int h, int size);
+
+
+#endif

text_rendering/stack.h

@@ -1,61 +1,72 @@
-#ifdef _STACK_TYPE
+#ifndef _STACK_GENERIC_H
-#ifdef _STACK_NAME
+#define _STACK_GENERIC_H
 
 
-#ifndef _STACK_REALLOC
+#define STACK_STEP 8
-	#define _STACK_REALLOC(p, s) realloc(p,s)
-#endif
-#ifndef _STACK_MEMSET
-	#define _STACK_MEMSET(p, c, s) memset(p,c,s)
-#endif
-#ifndef _STACK_STEP
-	#define _STACK_STEP 8
-#endif
-#ifndef _STACK_CAT
-	#define _STACK_CAT_I(a,b) a ## b
-	#define _STACK_CAT(a,b) _STACK_CAT_I(a,b)
-#endif
 
 
 // TODO: add a rolling hash
-struct _STACK_NAME {
+#define STACK_DECL(stackname, type)                                            \
-	_STACK_TYPE *items;
+struct stackname {                                                             \
-	int size, idx;
+	type *items;                                                           \
-};
+	int size, idx;                                                         \
-
+};                                                                             \
-
+\
-int _STACK_CAT(stack_grow_,_STACK_NAME)(struct _STACK_NAME *stack, int step)
+\
-{
+struct stackname stackname##_init(void) { return (struct stackname){0}; }      \
-	if (!stack)
+\
-		return -1;
+\
-	stack->items = _STACK_REALLOC(stack->items, (stack->size+step)*sizeof(_STACK_TYPE));
+int stackname##_grow(struct stackname *stack, int step)                        \
-	if(!stack->items)
+{                                                                              \
-		return -1;
+	if (!stack)                                                            \
-	_STACK_MEMSET(&(stack->items[stack->size]), 0, step*sizeof(*(stack->items)));
+		return -1;                                                     \
-	stack->size += step;
+	stack->items = realloc(stack->items, (stack->size+step)*sizeof(type)); \
-	return 0;
+	if(!stack->items)                                                      \
-}
+		return -1;                                                     \
-
+	memset(&(stack->items[stack->size]), 0, step*sizeof(*(stack->items))); \
-
+	stack->size += step;                                                   \
-int _STACK_CAT(stack_push_,_STACK_NAME)(struct _STACK_NAME *stack, _STACK_TYPE *e)
+	return 0;                                                              \
-{
+}                                                                              \
-	if (!stack || !e)
+\
-		return -1;
+\
-	if (stack->idx >= stack->size)
+int stackname##_push(struct stackname *stack, type *e)                         \
-		if (_STACK_CAT(stack_grow_,_STACK_NAME)(stack, _STACK_STEP))
+{                                                                              \
-			return -1;
+	if (!stack || !e)                                                      \
-	stack->items[stack->idx++] = *e;
+		return -1;                                                     \
-	return 0;
+	if (stack->idx >= stack->size)                                         \
-}
+		if (stackname##_grow(stack, STACK_STEP))                       \
-
+			return -1;                                             \
-
+	stack->items[stack->idx++] = *e;                                       \
-int _STACK_CAT(stack_clear_,_STACK_NAME)(struct _STACK_NAME *stack)
+	return 0;                                                              \
-{
+}                                                                              \
-	if (!stack)
+\
-		return -1;
+\
-	stack->idx = 0;
+type stackname##_pop(struct stackname *stack)                                  \
-}
+{                                                                              \
+	if (!stack || stack->idx == 0 || stack->size == 0)                     \
+		return (type){0};                                              \
+	return stack->items[stack->idx--];                                     \
+}                                                                              \
+\
+\
+int stackname##_clear(struct stackname *stack)                                 \
+{                                                                              \
+	if (!stack)                                                            \
+		return -1;                                                     \
+	stack->idx = 0;                                                        \
+	return 0;                                                              \
+}                                                                              \
+\
+\
+int stackname##_free(struct stackname *stack)                                  \
+{                                                                              \
+	if (stack) {                                                           \
+		stackname##_clear(stack);                                      \
+		if (stack->items)                                              \
+			free(stack->items);                                    \
+	}                                                                      \
+	return 0;                                                              \
+}                                                                              \
 
 
 #endif
-#endif

text_rendering/util.c

@@ -4,6 +4,7 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #include <err.h>
@@ -65,7 +66,7 @@ void map_file(const unsigned char **str, int *size, const char *path)
 }
 
 
-void dump_file(const char *path, unsigned char **buf, int *buf_len)
+void dump_file(const char *path, char **buf, int *buf_len)
 {
 	if (!path) {
 		errno = EINVAL;
@@ -75,10 +76,9 @@ void dump_file(const char *path, unsigned char **buf, int *buf_len)
 		errno = EINVAL;
 		err(EXIT_FAILURE, "No buffer specified");
 	}
-	if (!buf_len) {
+	int m = 0;
-		errno = EINVAL;
+	if (!buf_len)
-		err(EXIT_FAILURE, "Nowhere to store buffer size");
+		buf_len = &m;
-	}
 	FILE *fp = fopen(path, "r");
 	if (!fp)
 		err(EXIT_FAILURE, "Cannot open file %s", path);
@@ -86,7 +86,8 @@ void dump_file(const char *path, unsigned char **buf, int *buf_len)
 	rewind(fp);
 	if (*buf_len == (off_t)-1)
 		err(EXIT_FAILURE, "lseek() failed");
-	*buf = emalloc(*buf_len);
+	*buf = emalloc(*buf_len+1);
+	memset(*buf, 0, *buf_len+1);
 	int ret = fread(*buf, 1, *buf_len, fp);
 	if (ret != *buf_len)
 		err(EXIT_FAILURE, "fread() returned short %s", ferror(fp) ? "stream error" : feof(fp) ? "EOF reached" : "unknown error");

text_rendering/util.h

@@ -10,7 +10,7 @@ void * ecalloc(unsigned long int nmemb, unsigned long int size);
 void efree(void *ptr);
 
 void map_file(const unsigned char **str, int *size, const char *path);
-void dump_file(const char *path, unsigned char **buf, int *buf_len);
+void dump_file(const char *path, char **buf, int *buf_len);
 
 void print_byte(unsigned char byte);