idk cache I guess
This commit is contained in:
parent
dcce0ed11b
commit
e80d426872
Binary file not shown.
Before ![]() (image error) Size: 20 KiB After ![]() (image error) Size: 4.9 KiB ![]() ![]() |
@ -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_SET(x) bitmap[(x)/_BSIZE] |= 1<<((x)%_BSIZE)
|
||||
#define B_TEST(x) (bitmap[(x)/_BSIZE]&(1<<((x)%_BSIZE)))
|
||||
#define B_RESET() for (int i = 0; i < _BSIZE; bitmap[i++] = 0);
|
||||
#define B_SET(x) bitmap[(x)>>6] |= (uint64_t)1<<((x)%64)
|
||||
#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;
|
||||
}
|
||||
|
@ -1,42 +1,31 @@
|
||||
#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 "msdf_c/msdf.h"
|
||||
#include "stb_truetype.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
|
||||
// https://www.youtube.com/watch?v=1b5hIMqz_wM
|
||||
// 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
|
||||
|
||||
// as of now only monospaced fonts work correctly since no kerning information is stored
|
||||
|
||||
|
||||
const unsigned int glyph_w = 32;
|
||||
const unsigned int glyph_h = 32;
|
||||
// FIXME: as of now only monospaced fonts work correctly since no kerning information
|
||||
// is stored
|
||||
|
||||
|
||||
struct priv {
|
||||
stbtt_fontinfo stb;
|
||||
msdf_AllocCtx ctx;
|
||||
msdf_Result msdf;
|
||||
float scale;
|
||||
int baseline;
|
||||
unsigned char *bitmap;
|
||||
};
|
||||
#define PRIV(x) ((struct priv *)x->priv)
|
||||
|
||||
@ -56,8 +45,9 @@ struct font_atlas * font_init(void)
|
||||
}
|
||||
|
||||
|
||||
// loads a font into memory, storing all the ASCII characters in the atlas
|
||||
int font_load(struct font_atlas *atlas, const char *path)
|
||||
// loads a font into memory, storing all the ASCII characters in the atlas, each font
|
||||
// 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;
|
||||
@ -69,23 +59,24 @@ int font_load(struct font_atlas *atlas, const char *path)
|
||||
err = stbtt_InitFont(&(PRIV(atlas)->stb), (unsigned char *)atlas->file, 0);
|
||||
ERROR(err == 0, -1);
|
||||
|
||||
PRIV(atlas)->scale = stbtt_ScaleForPixelHeight(&(PRIV(atlas)->stb), glyph_h);
|
||||
//int ascent, descent, linegap, baseline;
|
||||
//int x0,y0,x1,y1;
|
||||
//stbtt_GetFontVMetrics(&(PRIV(atlas)->stb), &ascent, &descent, &linegap);
|
||||
//stbtt_GetFontBoundingBox(&(PRIV(atlas)->stb), &x0, &y0, &x1, &y1);
|
||||
//baseline = PRIV(atlas)->scale * -y0;
|
||||
//atlas->glyph_max_w = (PRIV(atlas)->scale*x1) - (PRIV(atlas)->scale*x0);
|
||||
//atlas->glyph_max_h = (baseline+PRIV(atlas)->scale*y1) - (baseline+PRIV(atlas)->scale*y0);
|
||||
//atlas->atlas = emalloc(atlas->glyph_max_w*atlas->glyph_max_h*CACHE_SIZE);
|
||||
|
||||
atlas->atlas = emalloc(CACHE_SIZE*BDEPTH*glyph_h*glyph_w);
|
||||
memset(atlas->atlas, 0, CACHE_SIZE*BDEPTH*glyph_h*glyph_w);
|
||||
int ascent, descent, linegap, baseline;
|
||||
int x0,y0,x1,y1;
|
||||
float scale;
|
||||
scale = stbtt_ScaleForPixelHeight(&(PRIV(atlas)->stb), size);
|
||||
stbtt_GetFontVMetrics(&(PRIV(atlas)->stb), &ascent, &descent, &linegap);
|
||||
stbtt_GetFontBoundingBox(&(PRIV(atlas)->stb), &x0, &y0, &x1, &y1);
|
||||
baseline = scale * -y0;
|
||||
atlas->glyph_max_w = (scale*x1) - (scale*x0);
|
||||
atlas->glyph_max_h = (baseline+scale*y1) - (baseline+scale*y0);
|
||||
atlas->atlas = emalloc(CACHE_SIZE*BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
|
||||
memset(atlas->atlas, 0, CACHE_SIZE*BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
|
||||
PRIV(atlas)->baseline = atlas->glyph_max_h - baseline;
|
||||
PRIV(atlas)->scale = scale;
|
||||
PRIV(atlas)->bitmap = emalloc(BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
|
||||
// FIXME: make this a square atlas
|
||||
atlas->width = glyph_w*CACHE_SIZE/4;
|
||||
atlas->height = glyph_h*4;
|
||||
|
||||
PRIV(atlas)->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();
|
||||
|
||||
@ -103,6 +94,7 @@ int font_free(struct font_atlas *atlas)
|
||||
{
|
||||
efree(atlas->atlas);
|
||||
efree(atlas->file);
|
||||
efree(PRIV(atlas)->bitmap);
|
||||
efree(atlas->priv);
|
||||
efree(atlas);
|
||||
cache_destroy();
|
||||
@ -127,73 +119,65 @@ const struct font_glyph * font_get_glyph_texture(struct font_atlas *atlas, unsig
|
||||
// generate the sdf and put it into the cache
|
||||
// TODO: generate the whole block at once
|
||||
int idx = stbtt_FindGlyphIndex(&PRIV(atlas)->stb, code);
|
||||
// FIXME: what happens if I change the range?
|
||||
int err;
|
||||
err = msdf_genGlyph(&PRIV(atlas)->msdf,
|
||||
int x0,y0,x1,y1,gw,gh,l,off_x,off_y,adv;
|
||||
stbtt_GetGlyphBitmapBoxSubpixel(
|
||||
&PRIV(atlas)->stb,
|
||||
idx,
|
||||
BORDER,
|
||||
PRIV(atlas)->scale,
|
||||
2.0f/glyph_h,
|
||||
&PRIV(atlas)->ctx);
|
||||
// msdf_genGlyph returns 0 only when there are no contours, so only for
|
||||
// whitespace and such, for those insert a zero uv map into the cache
|
||||
// FIXME: this is a waste of space
|
||||
if (!err) {
|
||||
PRIV(atlas)->msdf.width = 0;
|
||||
PRIV(atlas)->msdf.height = 0;
|
||||
}
|
||||
PRIV(atlas)->scale,
|
||||
0,0,
|
||||
&x0,&y0,
|
||||
&x1, &y1);
|
||||
gw = x1 - x0;
|
||||
gh = y1 - y0;
|
||||
stbtt_GetGlyphHMetrics(&PRIV(atlas)->stb, idx, &adv, &l);
|
||||
adv *= PRIV(atlas)->scale;
|
||||
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 ox = (glyph_h * spot) % atlas->height;
|
||||
unsigned int oy = ((atlas->glyph_max_w * spot) / atlas->width) * atlas->glyph_max_h;
|
||||
unsigned int ox = (atlas->glyph_max_w * spot) % atlas->width;
|
||||
unsigned int w = atlas->width;
|
||||
|
||||
// sum magic shit
|
||||
struct {unsigned char r,g,b;} *a = (void *)atlas->atlas;
|
||||
msdf_Result *res = &PRIV(atlas)->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;
|
||||
unsigned char *a = (void *)atlas->atlas;
|
||||
|
||||
#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++) {
|
||||
int yPos = res->width * 3 * y;
|
||||
for (int x = 0; x < res->width; x++) {
|
||||
|
||||
int i = yPos + (x * 3);
|
||||
float r = res->rgb[i+0];
|
||||
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;
|
||||
for (int y = 0; y < gh; y++) {
|
||||
for (int x = 0; x < gw; x++) {
|
||||
int c, r;
|
||||
r = (oy+y)*w;
|
||||
c = ox+x;
|
||||
a[r+c] = PRIV(atlas)->bitmap[y*atlas->glyph_max_w+x];
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: get the advance
|
||||
struct font_glyph g = {
|
||||
.codepoint = code,
|
||||
.u = ox,
|
||||
.v = oy,
|
||||
.w = res->width,
|
||||
.h = res->height,
|
||||
.w = gw,
|
||||
.h = gh,
|
||||
.x = off_x,
|
||||
.y = off_y,
|
||||
.a = adv,
|
||||
};
|
||||
const struct font_glyph *ret = cache_insert(&g, spot);
|
||||
|
||||
efree(PRIV(atlas)->msdf.rgb);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -4,29 +4,35 @@
|
||||
|
||||
/* width and height of a glyph contain the kering advance
|
||||
* (u,v)
|
||||
* +----------*---+ -
|
||||
* | .ii. | | ^
|
||||
* | @@@@@@. |<->| |
|
||||
* | V@Mio@@o |adv| |
|
||||
* | :i. V@V | | |
|
||||
* | :oM@@M | | |
|
||||
* | :@@@MM@M | | |
|
||||
* | @@o o@M | | |
|
||||
* |:@@. M@M | | |
|
||||
* | @@@o@@@@ | | |
|
||||
* | :M@@V:@@.| | v
|
||||
* +----------*---+ -
|
||||
* +-------------*---+ -
|
||||
* | ^ | | ^
|
||||
* | |oy | | |
|
||||
* | v | | |
|
||||
* | .ii. | | |
|
||||
* | @@@@@@. |<->| |
|
||||
* | V@Mio@@o |adv| |
|
||||
* | :i. V@V | | |
|
||||
* | :oM@@M | | |
|
||||
* | :@@@MM@M | | |
|
||||
* | @@o o@M | | |
|
||||
* |<->:@@. M@M | | |
|
||||
* |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 glyphs, width, height;
|
||||
unsigned int width, height;
|
||||
unsigned char *atlas;
|
||||
unsigned int glyph_max_w, glyph_max_h;
|
||||
int size;
|
||||
int file_size;
|
||||
char *file;
|
||||
void *priv;
|
||||
@ -34,7 +40,7 @@ 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, int *updated);
|
||||
void font_dump(const struct font_atlas *atlas, const char *path);
|
||||
|
14
text_rendering/font_fragshader.glsl
Normal file
14
text_rendering/font_fragshader.glsl
Normal file
@ -0,0 +1,14 @@
|
||||
#version 330
|
||||
|
||||
// viewsize.x = viewport width in pixels; viewsize.y = viewport height in pixels
|
||||
uniform vec2 viewsize;
|
||||
// texture uv coordinate in texture space
|
||||
in vec2 texture_coord;
|
||||
uniform sampler2D texture_sampler;
|
||||
|
||||
out vec4 color;
|
||||
|
||||
void main()
|
||||
{
|
||||
color = mix(vec4(0.0f,0.0f,0.0f,1.0f), vec4(1.0f,1.0f,1.0f,1.0f), texture(texture_sampler, texture_coord)) + vec4(1.0f,0.0f,0.0f,1.0f);
|
||||
}
|
20
text_rendering/font_vertshader.glsl
Normal file
20
text_rendering/font_vertshader.glsl
Normal file
@ -0,0 +1,20 @@
|
||||
#version 330 core
|
||||
|
||||
// viewsize.x = viewport width in pixels; viewsize.y = viewport height in pixels
|
||||
uniform vec2 viewsize;
|
||||
|
||||
// both position and and uv are in pixels
|
||||
layout(location = 0) in vec2 position;
|
||||
layout(location = 1) in vec2 uv;
|
||||
|
||||
out vec2 texture_coord;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec4 pos = vec4(position.x, position.y, 0.0f, 1.0f);
|
||||
vec2 v = viewsize / 2;
|
||||
pos.xy = (pos.xy - v) / v;
|
||||
|
||||
gl_Position = pos;
|
||||
texture_coord = uv / viewsize;
|
||||
}
|
@ -1,3 +1,5 @@
|
||||
#include <SDL2/SDL.h>
|
||||
#include <SDL2/SDL_events.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
@ -22,9 +24,15 @@ int main(void)
|
||||
ren_render_text("ciao mamma", 100, 100, 100, 100, 12);
|
||||
SDL_GL_SwapWindow(win);
|
||||
|
||||
while(1);
|
||||
SDL_Event e;
|
||||
while(1) {
|
||||
SDL_WaitEvent(&e);
|
||||
if (e.type == SDL_QUIT)
|
||||
break;
|
||||
}
|
||||
|
||||
ren_free();
|
||||
SDL_DestroyWindow(win);
|
||||
SDL_Quit();
|
||||
return 0;
|
||||
}
|
||||
|
3
text_rendering/msdf_c/.gitignore
vendored
3
text_rendering/msdf_c/.gitignore
vendored
@ -1,3 +0,0 @@
|
||||
build
|
||||
.vscode
|
||||
.DS_Store
|
@ -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);
|
||||
}
|
||||
~~~
|
@ -1,4 +0,0 @@
|
||||
#define STB_TRUETYPE_IMPLEMENTATION
|
||||
#include "stb_truetype.h"
|
||||
#define MSDF_IMPLEMENTATION
|
||||
#include "msdf.h"
|
File diff suppressed because it is too large
Load Diff
Binary file not shown.
@ -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.
|
Binary file not shown.
@ -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;
|
||||
}
|
Binary file not shown.
Before ![]() (image error) Size: 600 B |
File diff suppressed because it is too large
Load Diff
@ -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_ */
|
@ -24,6 +24,7 @@ enum REN_ERR {
|
||||
REN_GLEW,
|
||||
REN_FONT,
|
||||
REN_BUFFER,
|
||||
REN_UNIFORM,
|
||||
};
|
||||
|
||||
|
||||
@ -42,6 +43,7 @@ const char * ren_err_msg[] = {
|
||||
[REN_GLEW] = "GLEW Error",
|
||||
[REN_FONT] = "Font Error",
|
||||
[REN_BUFFER] = "Failed to create opengl buffer",
|
||||
[REN_UNIFORM] = "Failed to get uniform location",
|
||||
};
|
||||
|
||||
// different stacks
|
||||
@ -57,6 +59,7 @@ struct {
|
||||
GLuint font_prog;
|
||||
GLuint box_prog;
|
||||
GLuint font_buffer;
|
||||
GLint viewsize_loc;
|
||||
struct vtstack font_stack;
|
||||
struct vcstack box_stack;
|
||||
} ren = {0};
|
||||
@ -227,6 +230,29 @@ static GLuint ren_texturergba_2d(const char *buf, int w, int h, int upscale, int
|
||||
}
|
||||
|
||||
|
||||
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)
|
||||
|
||||
glGenTextures(1, &t);
|
||||
if (!t) REN_RET(0, REN_TEXTURE)
|
||||
|
||||
glBindTexture(GL_TEXTURE_2D, t);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_R, w, h, 0, GL_R, GL_UNSIGNED_BYTE, buf);
|
||||
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, downscale);
|
||||
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)
|
||||
{
|
||||
@ -235,7 +261,7 @@ static int update_font_texture(void)
|
||||
0, 0, 0,
|
||||
ren.font->width,
|
||||
ren.font->height,
|
||||
GL_RGB,
|
||||
GL_R,
|
||||
GL_UNSIGNED_BYTE,
|
||||
ren.font->atlas);
|
||||
font_dump(ren.font, "./atlas.png");
|
||||
@ -266,9 +292,10 @@ int ren_init(SDL_Window *w)
|
||||
|
||||
ren.font = font_init();
|
||||
if (!ren.font) REN_RET(-1, REN_FONT)
|
||||
if (font_load(ren.font, FONT_PATH)) REN_RET(-1, REN_FONT)
|
||||
if (font_load(ren.font, FONT_PATH, 12)) REN_RET(-1, REN_FONT)
|
||||
font_dump(ren.font, "./atlas.png");
|
||||
|
||||
ren.font_texture = ren_texturergb_2d(
|
||||
ren.font_texture = ren_texturer_2d(
|
||||
(const char *)ren.font->atlas,
|
||||
ren.font->width,
|
||||
ren.font->height,
|
||||
@ -281,6 +308,7 @@ int ren_init(SDL_Window *w)
|
||||
ren.font_stack = vtstack_init();
|
||||
ren.box_stack = vcstack_init();
|
||||
|
||||
// generate the font buffer object
|
||||
glGenBuffers(1, &ren.font_buffer);
|
||||
if (!ren.font_buffer) REN_RET(-1, REN_BUFFER)
|
||||
glBindBuffer(GL_ARRAY_BUFFER, ren.font_buffer);
|
||||
@ -303,6 +331,10 @@ int ren_init(SDL_Window *w)
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
|
||||
// create the uniforms
|
||||
ren.viewsize_loc = glGetUniformLocation(ren.font_prog, "viewsize");
|
||||
if (ren.viewsize_loc == -1) REN_RET(-1, REN_UNIFORM)
|
||||
|
||||
int width, height;
|
||||
SDL_GetWindowSize(w, &width, &height);
|
||||
ren_update_viewport(width, height);
|
||||
@ -335,7 +367,7 @@ static int ren_draw_font_stack(void)
|
||||
int ren_update_viewport(int w, int h)
|
||||
{
|
||||
glViewport(0, 0, w, h);
|
||||
glUniform2i(REN_SCREENSIZE_LOC, w, h);
|
||||
glUniform2i(ren.viewsize_loc, w, h);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -368,35 +400,38 @@ int ren_render_text(const char *str, int x, int y, int w, int h, int size)
|
||||
REN_RET(-1, REN_TEXTURE);
|
||||
}
|
||||
|
||||
printf("g: u=%d v=%d w=%d h=%d a=%d x=%d y=%d\n", g->u, g->v, g->w, g->h, g->a, g->x, g->y);
|
||||
|
||||
// x1,y1
|
||||
v = (struct v_text){
|
||||
.pos = { .x = gx, .y = gy+g->h },
|
||||
.uv = { .u = g->u, .v = g->v+g->h },
|
||||
.pos = { .x = gx+g->x, .y = gy+g->y+g->h },
|
||||
.uv = { .u = g->u, .v = g->v+g->h },
|
||||
};
|
||||
vtstack_push(&ren.font_stack, &v);
|
||||
// x2,y2
|
||||
v = (struct v_text){
|
||||
.pos = { .x = gx+g->w, .y = gy+g->h },
|
||||
.uv = { .u = g->u+g->w, .v = g->v+g->h },
|
||||
.pos = { .x = gx+g->x+g->w, .y = gy+g->y+g->h },
|
||||
.uv = { .u = g->u+g->w, .v = g->v+g->h },
|
||||
};
|
||||
vtstack_push(&ren.font_stack, &v);
|
||||
// x3,y3
|
||||
v = (struct v_text){
|
||||
.pos = { .x = gx+g->w, .y = gy },
|
||||
.uv = { .u = g->u+g->w, .v = g->v },
|
||||
.pos = { .x = gx+g->x+g->w, .y = gy+g->y },
|
||||
.uv = { .u = g->u+g->w, .v = g->v },
|
||||
};
|
||||
vtstack_push(&ren.font_stack, &v);
|
||||
// x4,y4
|
||||
v = (struct v_text){
|
||||
.pos = { .x = gx, .y = gy },
|
||||
.uv = { .u = g->u, .v = g->v },
|
||||
.pos = { .x = gx+g->x, .y = gy+g->y },
|
||||
.uv = { .u = g->u, .v = g->v },
|
||||
};
|
||||
vtstack_push(&ren.font_stack, &v);
|
||||
|
||||
// TODO: possible kerning needs to be applied here
|
||||
gx += g->w;
|
||||
gx += g->w + g->a;
|
||||
if (cp == '\n')
|
||||
gy += 20; // FIXME: encode and/or store line height
|
||||
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
|
||||
|
@ -10,7 +10,6 @@
|
||||
#define REN_VERTEX_IDX 0
|
||||
#define REN_UV_IDX 1
|
||||
#define REN_COLOR_IDX 2
|
||||
#define REN_SCREENSIZE_LOC 0
|
||||
|
||||
|
||||
typedef struct {
|
||||
|
@ -5074,4 +5074,4 @@ AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
*/
|
||||
*/
|
Binary file not shown.
Loading…
Reference in New Issue
Block a user