// ------------------------------------------------------------------- init ---
void init( void )
{
atlas = texture_atlas_new( 512, 512, 1 );
auto filename = "fonts/Vera.ttf";
auto text = "A Quick Brown Fox Jumps Over The Lazy Dog 0123456789";
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
vec2 pen = {0,0};
auto black = vec4{1,1,1,1};
auto font = texture_font_new_from_file( atlas, 48, filename );
font->rendermode = RENDER_SIGNED_DISTANCE_FIELD;
auto bbox = add_text( buffer, font, text, &black, &pen );
size_t i;
auto vertices = buffer->vertices;
for( i=0; i< vector_size(vertices); ++i ) {
auto vert = (vertex *) vector_get(vertices,i);
vert->x -= (int)(bbox.x + bbox.width/2);
vert->y -= (int)(bbox.y + bbox.height/2);
}
glGenTextures( 1, &atlas->id );
glBindTexture( GL_TEXTURE_2D, atlas->id );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RED, atlas->width, atlas->height,
0, GL_RED, GL_UNSIGNED_BYTE, atlas->data );
shader = shader_load( "shaders/distance-field-2v5.vert",
"shaders/distance-field-2v5.frag" );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
// ------------------------------------------------------------------- init ---
void init( void )
{
size_t i;
vec2 pen = {{0,0}};
vec4 color = {{0,0,0,1}};
atlas = texture_atlas_new( 512, 512, 1 );
font = texture_font_new_from_file( atlas, 12, "../media/fonts/VeraMono.ttf" );
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
pen.y = -font->descender;
for( i=0; i<line_count; ++i )
{
pen.x = 10.0;
add_text( buffer, font, text, &color, &pen );
pen.y += font->height - font->linegap;
}
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glDisable( GL_DEPTH_TEST );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_TEXTURE_2D );
glEnable( GL_BLEND );
shader = shader_load("../media/shaders/v3f-t2f-c4f.vert",
"../media/shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
/* ------------------------------------------------------------------ main - */
int main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitWindowSize( 800, 500 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( argv[0] );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
buffer = text_buffer_new( LCD_FILTERING_OFF );
vec4 black = {{0.0, 0.0, 0.0, 1.0}};
vec4 none = {{1.0, 1.0, 1.0, 0.0}};
markup_t markup;
markup.family = "fonts/VeraMono.ttf",
markup.size = 15.0;
markup.bold = 0;
markup.italic = 0;
markup.rise = 0.0;
markup.spacing = 0.0;
markup.gamma = 1.0;
markup.foreground_color = black;
markup.background_color = none;
markup.underline = 0;
markup.underline_color = black;
markup.overline = 0;
markup.overline_color = black;
markup.strikethrough = 0;
markup.strikethrough_color = black;
markup.font = 0;
vec2 pen = {{10.0, 480.0}};
FILE *file = fopen ( "data/256colors.txt", "r" );
if ( file != NULL )
{
wchar_t line[1024];
while( fgetws ( line, sizeof(line), file ) != NULL )
{
print( buffer, &pen, line, &markup );
}
fclose ( file );
}
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop( );
return 0;
}
TextRender::TextRender()
{
mat4_set_identity(&m_projection);
mat4_set_identity(&m_model);
mat4_set_identity(&m_view);
setup_other_text();
}
// ------------------------------------------------------------------- init ---
void init( void )
{
atlas = texture_atlas_new( 512, 512, 1 );
font = texture_font_new_from_file( atlas, 32, "../media/fonts/Vera.ttf" );
texture_glyph_t *glyph;
// Generate the glyp at 512 points, compute distance field and scale it
// back to 32 points
// Just load another glyph if you want to see difference (draw render a '@')
glyph = load_glyph( "../media/fonts/Vera.ttf", "@", 512, 64, 0.1);
vector_push_back( font->glyphs, &glyph );
texture_atlas_upload( atlas );
glyph = texture_font_get_glyph( font, "@");
GLuint indices[6] = {0,1,2, 0,2,3};
vertex_t vertices[4] = { { -.5,-.5,0, glyph->s0,glyph->t1, 0,0,0,1 },
{ -.5, .5,0, glyph->s0,glyph->t0, 0,0,0,1 },
{ .5, .5,0, glyph->s1,glyph->t0, 0,0,0,1 },
{ .5,-.5,0, glyph->s1,glyph->t1, 0,0,0,1 } };
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
vertex_buffer_push_back( buffer, vertices, 4, indices, 6 );
program = shader_load( "../media/shaders/distance-field.vert",
"../media/shaders/distance-field-2.frag" );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
// ------------------------------------------------------------------- init ---
void init( void )
{
control_key_handled = 0;
console = console_new();
console_print( console,
"OpenGL Freetype console\n"
"Copyright 2011 Nicolas P. Rougier. All rights reserved.\n \n" );
console_connect( console, "activate", console_activate );
console_connect( console, "complete", console_complete );
console_connect( console, "history-prev", console_history_prev );
console_connect( console, "history-next", console_history_next );
glClearColor( 1.00, 1.00, 1.00, 1.00 );
glDisable( GL_DEPTH_TEST );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_TEXTURE_2D );
glEnable( GL_BLEND );
shader = shader_load("shaders/v3f-t2f-c4f.vert",
"shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
void CFont::Init()
{
vec4 white = { { 1.0, 1.0, 1.0, 1.0 } };
vec4 none = { { 1.0, 1.0, 1.0, 0.0 } };
buffer = text_buffer_new();
std::string fontName(FONT_NAME);
fontPath = GetSystemFontFile(fontName);
normal.family = (char*)fontPath.c_str();
normal.size = 13.0f;
normal.bold = 0;
normal.italic = 0;
normal.spacing = 0.0;
normal.gamma = 2.;
normal.foreground_color = white;
normal.background_color = none;
normal.underline = 0;
normal.underline_color = white;
normal.overline = 0;
normal.overline_color = white;
normal.strikethrough = 0;
normal.strikethrough_color = white;
mat4_set_identity(&projection);
mat4_set_identity(&model);
mat4_set_identity(&view);
}
// ------------------------------------------------------------------- main ---
int
main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitWindowSize( 800, 600 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( "Signed Distance Field" );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
texture_font_t *font = 0;
texture_atlas_t *atlas = texture_atlas_new( 512, 512, 1 );
const char * filename = "fonts/Vera.ttf";
wchar_t *text = L"A Quick Brown Fox Jumps Over The Lazy Dog 0123456789";
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
vec2 pen = {{0,0}};
vec4 black = {{1,1,1,1}};
font = texture_font_new_from_file( atlas, 48, filename );
vec4 bbox = add_text( buffer, font, text, &black, &pen );
size_t i;
vector_t * vertices = buffer->vertices;
for( i=0; i< vector_size(vertices); ++i )
{
vertex_t * vertex = (vertex_t *) vector_get(vertices,i);
vertex->x -= (int)(bbox.x + bbox.width/2);
vertex->y -= (int)(bbox.y + bbox.height/2);
}
glBindTexture( GL_TEXTURE_2D, atlas->id );
fprintf( stderr, "Generating distance map...\n" );
unsigned char *map = make_distance_map(atlas->data, atlas->width, atlas->height);
fprintf( stderr, "done !\n");
memcpy( atlas->data, map, atlas->width*atlas->height*sizeof(unsigned char) );
free(map);
texture_atlas_upload( atlas );
shader = shader_load( "shaders/distance-field-2.vert",
"shaders/distance-field-2.frag" );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop( );
return 0;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
size_t width = 800, height = 200;
glutInit( &argc, argv );
glutInitWindowSize( width, height );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( "Glyph Cartoon" );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
atlas = texture_atlas_new( 1024, 1024, 1 );
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
texture_font_t *font =
texture_font_new_from_file( atlas, 128, "fonts/ObelixPro.ttf" );
vec2 pen = {{50, 50}};
vec4 black = {{0.0, 0.0, 0.0, 1.0}};
vec4 yellow = {{1.0, 1.0, 0.0, 1.0}};
vec4 orange1 = {{1.0, 0.9, 0.0, 1.0}};
vec4 orange2 = {{1.0, 0.6, 0.0, 1.0}};
font->outline_type = 2;
font->outline_thickness = 7;
add_text( buffer, font, L"Freetype GL", pen, black, black );
font->outline_type = 2;
font->outline_thickness = 5;
add_text( buffer, font, L"Freetype GL", pen, yellow, yellow );
font->outline_type = 1;
font->outline_thickness = 3;
add_text( buffer, font, L"Freetype GL", pen, black, black );
font->outline_type = 0;
font->outline_thickness = 0;
add_text( buffer, font, L"Freetype GL", pen, orange1, orange2 );
shader = shader_load("shaders/v3f-t2f-c4f.vert",
"shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop( );
return 0;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
size_t i;
vec4 color = {{0,0,0,1}};
vec2 pen = {{0,0}};
glutInit( &argc, argv );
glutInitWindowSize( 800, 600 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( "Freetype OpenGL benchmark" );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
glutIdleFunc( idle );
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
atlas = texture_atlas_new( 512, 512, 1 );
font = texture_font_new( atlas, "fonts/VeraMono.ttf", 12 );
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
pen.y = -font->descender;
for( i=0; i<line_count; ++i )
{
pen.x = 10.0;
add_text( buffer, font, text, &color, &pen );
pen.y += font->height - font->linegap;
}
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glDisable( GL_DEPTH_TEST );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_TEXTURE_2D );
glEnable( GL_BLEND );
shader = shader_load("shaders/v3f-t2f-c4f.vert",
"shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop( );
return EXIT_SUCCESS;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitWindowSize( 800, 400 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( "Freetype OpenGL / LCD filtering" );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
size_t i;
texture_font_t *font = 0;
atlas = texture_atlas_new( 512, 512, 3 );
const char * filename = "fonts/Vera.ttf";
wchar_t *text = L"A Quick Brown Fox Jumps Over The Lazy Dog 0123456789";
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f,ashift:1f,agamma:1f" );
vec2 pen = {{0,0}};
vec4 color = {{0,0,0,1}};
for( i=7; i < 27; ++i)
{
font = texture_font_new_from_file( atlas, i, filename );
pen.x = 0;
pen.y -= font->height;
texture_font_load_glyphs( font, text );
add_text( buffer, font, text, &color, &pen );
texture_font_delete( font );
}
glBindTexture( GL_TEXTURE_2D, atlas->id );
shader = shader_load( "shaders/text.vert",
"shaders/text.frag" );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop( );
return 0;
}
int
main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( argv[0] );
glutReshapeFunc( on_reshape );
glutDisplayFunc( on_display );
glutKeyboardFunc( on_key_press );
glutSpecialFunc( on_special_key_press );
glutReshapeWindow( 600,400 );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
console = console_new();
console_print( console,
L"OpenGL Freetype console\n"
L"Copyright 2011 Nicolas P. Rougier. All rights reserved.\n \n" );
console_connect( console, "activate", console_activate );
console_connect( console, "complete", console_complete );
console_connect( console, "history-prev", console_history_prev );
console_connect( console, "history-next", console_history_next );
glClearColor( 1.00, 1.00, 1.00, 1.00 );
glDisable( GL_DEPTH_TEST );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_TEXTURE_2D );
glEnable( GL_BLEND );
shader = shader_load("shaders/v3f-t2f-c4f.vert",
"shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop();
return 0;
}
// ------------------------------------------------------------------- init ---
void init( void )
{
atlas = texture_atlas_new( 1024, 1024, 1 );
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
texture_font_t *font =
texture_font_new_from_file( atlas, 128, "fonts/LuckiestGuy.ttf" );
vec2 pen = {{50, 50}};
vec4 black = {{0.0, 0.0, 0.0, 1.0}};
vec4 yellow = {{1.0, 1.0, 0.0, 1.0}};
vec4 orange1 = {{1.0, 0.9, 0.0, 1.0}};
vec4 orange2 = {{1.0, 0.6, 0.0, 1.0}};
font->rendermode = RENDER_OUTLINE_POSITIVE;
font->outline_thickness = 7;
add_text( buffer, font, "Freetype GL", pen, black, black );
font->rendermode = RENDER_OUTLINE_POSITIVE;
font->outline_thickness = 5;
add_text( buffer, font, "Freetype GL", pen, yellow, yellow );
font->rendermode = RENDER_OUTLINE_EDGE;
font->outline_thickness = 3;
add_text( buffer, font, "Freetype GL", pen, black, black );
font->rendermode = RENDER_NORMAL;
font->outline_thickness = 0;
add_text( buffer, font, "Freetype GL", pen, orange1, orange2 );
glGenTextures( 1, &atlas->id );
glBindTexture( GL_TEXTURE_2D, atlas->id );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RED, atlas->width, atlas->height,
0, GL_RED, GL_UNSIGNED_BYTE, atlas->data );
shader = shader_load("shaders/v3f-t2f-c4f.vert",
"shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
static int on_move(gesture3d_t *gest, void *user)
{
float face_plane[4][4];
cursor_t *curs = gest->cursor;
tool_move_t *tool = user;
float n[3], pos[3], d[3], ofs[3], v[3];
layer_t *layer = goxel->image->active_layer;
float mat[4][4];
if (box_is_null(tool->box)) return GESTURE_FAILED;
if (gest->type == GESTURE_HOVER) {
goxel_set_help_text(goxel, "Drag to move face");
if (curs->snaped != SNAP_LAYER_OUT) return GESTURE_FAILED;
tool->snap_face = get_face(curs->normal);
curs->snap_offset = 0;
curs->snap_mask &= ~SNAP_ROUNDED;
mat4_mul(tool->box, FACES_MATS[tool->snap_face], face_plane);
render_img(&goxel->rend, NULL, face_plane, EFFECT_NO_SHADING);
if (curs->flags & CURSOR_PRESSED) {
gest->type = GESTURE_DRAG;
vec3_normalize(face_plane[0], v);
plane_from_vectors(goxel->tool_plane, curs->pos, curs->normal, v);
image_history_push(goxel->image);
}
return 0;
}
if (gest->type == GESTURE_DRAG) {
goxel_set_help_text(goxel, "Drag to move face");
curs->snap_offset = 0;
curs->snap_mask &= ~SNAP_ROUNDED;
mat4_mul(tool->box, FACES_MATS[tool->snap_face], face_plane);
vec3_normalize(face_plane[2], n);
vec3_sub(curs->pos, goxel->tool_plane[3], v);
vec3_project(v, n, v);
vec3_add(goxel->tool_plane[3], v, pos);
pos[0] = round(pos[0]);
pos[1] = round(pos[1]);
pos[2] = round(pos[2]);
vec3_add(tool->box[3], face_plane[2], d);
vec3_sub(pos, d, ofs);
vec3_project(ofs, n, ofs);
mat4_set_identity(mat);
mat4_itranslate(mat, ofs[0], ofs[1], ofs[2]);
do_move(layer, mat);
if (gest->state == GESTURE_END) {
gest->type = GESTURE_HOVER;
mat4_copy(plane_null, goxel->tool_plane);
}
return 0;
}
return 0;
}
// ------------------------------------------------------------------- init ---
void init( void )
{
buffer = text_buffer_new( LCD_FILTERING_OFF,
"../media/shaders/text.vert",
"../media/shaders/text.frag" );
vec4 black = {{0.0, 0.0, 0.0, 1.0}};
vec4 none = {{1.0, 1.0, 1.0, 0.0}};
markup_t markup;
markup.family = "../media/fonts/VeraMono.ttf";
markup.size = 15.0;
markup.bold = 0;
markup.italic = 0;
markup.rise = 0.0;
markup.spacing = 0.0;
markup.gamma = 1.0;
markup.foreground_color = black;
markup.background_color = none;
markup.underline = 0;
markup.underline_color = black;
markup.overline = 0;
markup.overline_color = black;
markup.strikethrough = 0;
markup.strikethrough_color = black;
markup.font = 0;
vec2 pen = {{10.0, 480.0}};
FILE *file = fopen ( "../media/color-data/256colors.txt", "r" );
if ( file != NULL )
{
char line[1024];
while( fgets ( line, sizeof(line), file ) != NULL )
{
print( buffer, &pen, line, &markup );
}
fclose ( file );
}
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
// ---------------------------------------------------------------- display ---
void display( GLFWwindow* window )
{
static float theta=0, phi=0;
static GLuint Color = 0;
double seconds_elapsed = glfwGetTime( );
if( !Color )
{
Color = glGetUniformLocation( shader, "Color" );
}
theta = .5f * seconds_elapsed / 0.016f;
phi = .5f * seconds_elapsed / 0.016f;
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
mat4_set_identity( &model );
mat4_rotate( &model, theta, 0, 0, 1 );
mat4_rotate( &model, phi, 0, 1, 0 );
mat4_translate( &model, 0.0, 0.0, -5.0 );
glDisable( GL_BLEND );
glEnable( GL_DEPTH_TEST );
glEnable( GL_POLYGON_OFFSET_FILL );
glUseProgram( shader );
{
glUniformMatrix4fv( glGetUniformLocation( shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ),
1, 0, projection.data);
}
glUniform4f( Color, 1, 1, 1, 1 );
vertex_buffer_render( cube, GL_QUADS );
glDisable( GL_POLYGON_OFFSET_FILL );
glEnable( GL_BLEND );
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
glDepthMask( GL_FALSE );
glUniform4f( Color, 0, 0, 0, .5 );
vertex_buffer_render( cube, GL_QUADS );
glUseProgram( 0 );
glDepthMask( GL_TRUE );
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glfwSwapBuffers( window );
}
// ------------------------------------------------------------------- init ---
void init( void )
{
texture_font_t *font = 0;
texture_atlas_t *atlas = texture_atlas_new( 512, 512, 1 );
const char * filename = "fonts/Vera.ttf";
char *text = "A Quick Brown Fox Jumps Over The Lazy Dog 0123456789";
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
vec2 pen = {{0,0}};
vec4 black = {{1,1,1,1}};
font = texture_font_new_from_file( atlas, 48, filename );
vec4 bbox = add_text( buffer, font, text, &black, &pen );
texture_atlas_upload( font->atlas );
size_t i;
vector_t * vertices = buffer->vertices;
for( i=0; i< vector_size(vertices); ++i )
{
vertex_t * vertex = (vertex_t *) vector_get(vertices,i);
vertex->x -= (int)(bbox.x + bbox.width/2);
vertex->y -= (int)(bbox.y + bbox.height/2);
}
glBindTexture( GL_TEXTURE_2D, atlas->id );
fprintf( stderr, "Generating distance map...\n" );
unsigned char *map = make_distance_mapb(atlas->data, atlas->width, atlas->height);
fprintf( stderr, "done !\n");
memcpy( atlas->data, map, atlas->width*atlas->height*sizeof(unsigned char) );
free(map);
texture_atlas_upload( atlas );
shader = shader_load( "shaders/distance-field.vert",
"shaders/distance-field-2.frag" );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
// ------------------------------------------------------------------- init ---
void init( void )
{
typedef struct { float x,y,z;} xyz;
typedef struct { float r,g,b,a;} rgba;
typedef struct { xyz position, normal; rgba color;} vertex;
xyz v[] = { { 1, 1, 1}, {-1, 1, 1}, {-1,-1, 1}, { 1,-1, 1},
{ 1,-1,-1}, { 1, 1,-1}, {-1, 1,-1}, {-1,-1,-1} };
xyz n[] = { { 0, 0, 1}, { 1, 0, 0}, { 0, 1, 0} ,
{-1, 0, 1}, { 0,-1, 0}, { 0, 0,-1} };
rgba c[] = { {1, 1, 1, 1}, {1, 1, 0, 1}, {1, 0, 1, 1}, {0, 1, 1, 1},
{1, 0, 0, 1}, {0, 0, 1, 1}, {0, 1, 0, 1}, {0, 0, 0, 1} };
vertex vertices[24] = {
{v[0],n[0],c[0]}, {v[1],n[0],c[1]}, {v[2],n[0],c[2]}, {v[3],n[0],c[3]},
{v[0],n[1],c[0]}, {v[3],n[1],c[3]}, {v[4],n[1],c[4]}, {v[5],n[1],c[5]},
{v[0],n[2],c[0]}, {v[5],n[2],c[5]}, {v[6],n[2],c[6]}, {v[1],n[2],c[1]},
{v[1],n[3],c[1]}, {v[6],n[3],c[6]}, {v[7],n[3],c[7]}, {v[2],n[3],c[2]},
{v[7],n[4],c[7]}, {v[4],n[4],c[4]}, {v[3],n[4],c[3]}, {v[2],n[4],c[2]},
{v[4],n[5],c[4]}, {v[7],n[5],c[7]}, {v[6],n[5],c[6]}, {v[5],n[5],c[5]} };
GLuint indices[24] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,
12,13,14,15, 16,17,18,19, 20,21,22,23 };
cube = vertex_buffer_new( "vertex:3f,normal:3f,color:4f" );
vertex_buffer_push_back( cube, vertices, 24, indices, 24 );
shader = shader_load("../media/shaders/cube.vert","../media/shaders/cube.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glPolygonOffset( 1, 1 );
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glEnable( GL_DEPTH_TEST );
glEnable( GL_COLOR_MATERIAL );
glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_LINE_SMOOTH );
}
// ------------------------------------------------------------------- init ---
void init( void )
{
size_t i;
texture_font_t *font = 0;
atlas = texture_atlas_new( 512, 512, 3 );
const char * filename = "fonts/Vera.ttf";
char * text = "A Quick Brown Fox Jumps Over The Lazy Dog 0123456789";
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f,ashift:1f,agamma:1f" );
vec2 pen = {{0,0}};
vec4 color = {{0,0,0,1}};
for( i=7; i < 27; ++i)
{
font = texture_font_new_from_file( atlas, i, filename );
pen.x = 0;
pen.y -= font->height;
texture_font_load_glyphs( font, text );
add_text( buffer, font, text, &color, &pen );
texture_font_delete( font );
}
glGenTextures( 1, &atlas->id );
glBindTexture( GL_TEXTURE_2D, atlas->id );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, atlas->width, atlas->height,
0, GL_RGB, GL_UNSIGNED_BYTE, atlas->data );
shader = shader_load( "shaders/text.vert",
"shaders/text.frag" );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
// ---------------------------------------------------------------- display ---
void display( GLFWwindow* window )
{
glClearColor(1.0,1.0,1.0,1.0);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, atlas->id);
glEnable( GL_TEXTURE_2D );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
texture_glyph_t * glyph = texture_font_get_glyph( font, "@");
int width = 512;
int height = 512;
float glyph_height = glyph->height * width/(float)glyph->width;
float glyph_width = glyph->width * height/(float)glyph->height;
int x = -glyph_width/2 + 512/2.;
int y = -glyph_height/2 + 512/2.;
float s = .025+.975*(1+cos(angle/100.0))/2.;
vec4 color = {{1.0, 1.0, 1.0, 1.0 }};
mat4_set_identity( &model );
mat4_scale( &model, width * s, width * s, 1 );
mat4_rotate( &model, angle, 0, 0, 1 );
mat4_translate( &model, 256, 256, 0 );
glUseProgram( program );
{
glUniform1i( glGetUniformLocation( program, "u_texture" ),
0);
glUniform4f( glGetUniformLocation( program, "u_color" ),
color.r, color.g, color.b, color.a);
glUniformMatrix4fv( glGetUniformLocation( program, "u_model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( program, "u_view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( program, "u_projection" ),
1, 0, projection.data);
vertex_buffer_render( buffer, GL_TRIANGLES );
}
glfwSwapBuffers( window );
}
// ---------------------------------------------------------------- display ---
void display( GLFWwindow* window )
{
glClearColor( 1, 1, 1, 1 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
GLint viewport[4];
glGetIntegerv( GL_VIEWPORT, viewport );
GLint width = viewport[2];
GLint height = viewport[3];
srand(4);
vec4 color = {{0.067,0.333, 0.486, 1.0}};
size_t i;
for( i=0; i<40; ++i)
{
float scale = .25 + 4.75 * pow(rand()/(float)(RAND_MAX),2);
float angle = 90*(rand()%2);
float x = (.05 + .9*(rand()/(float)(RAND_MAX)))*width;
float y = (-.05 + .9*(rand()/(float)(RAND_MAX)))*height;
float a = 0.1+.8*(pow((1.0-scale/5),2));
mat4_set_identity( &model );
mat4_rotate( &model, angle,0,0,1);
mat4_scale( &model, scale, scale, 1);
mat4_translate( &model, x, y, 0);
glUseProgram( shader );
{
glUniform1i( glGetUniformLocation( shader, "u_texture" ),
0 );
glUniform4f( glGetUniformLocation( shader, "u_color" ),
color.r, color.g, color.b, a);
glUniformMatrix4fv( glGetUniformLocation( shader, "u_model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "u_view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "u_projection" ),
1, 0, projection.data);
vertex_buffer_render( buffer, GL_TRIANGLES );
}
}
glfwSwapBuffers( window );
}
// ---------------------------------------------------------------- display ---
void display( void )
{
int viewport[4];
glGetIntegerv( GL_VIEWPORT, viewport );
glClearColor(1,1,1,1);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_TEXTURE_2D );
glEnable( GL_COLOR_MATERIAL );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glColor4f( 0, 0, 0, 1 );
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
glBlendColor( 1, 1, 1, 1 );
glEnable( GL_BLEND );
mat4_set_identity( &model );
mat4_translate( &model, 5, viewport[3], 0);
glUseProgram( shader );
{
glUniform1i( glGetUniformLocation( shader, "texture" ),
0 );
glUniform3f( glGetUniformLocation( shader, "pixel" ),
1.0/atlas->width, 1.0/atlas->height, atlas->depth );
glUniformMatrix4fv( glGetUniformLocation( shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ),
1, 0, projection.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ),
1, 0, projection.data);
vertex_buffer_render( buffer, GL_TRIANGLES );
}
glutSwapBuffers( );
}
static void do_move(layer_t *layer, const float mat[4][4])
{
float m[4][4];
mat4_set_identity(m);
// Change referential to the mesh origin.
// XXX: maybe this should be done in mesh_move directy??
mat4_itranslate(m, -0.5, -0.5, -0.5);
mat4_imul(m, mat);
mat4_itranslate(m, +0.5, +0.5, +0.5);
if (layer->base_id || layer->image) {
mat4_mul(mat, layer->mat, layer->mat);
layer->base_mesh_key = 0;
} else {
mesh_move(layer->mesh, m);
if (!box_is_null(layer->box)) {
mat4_mul(mat, layer->box, layer->box);
box_get_bbox(layer->box, layer->box);
}
}
goxel_update_meshes(goxel, -1);
}
// ------------------------------------------------------------------- main ---
int main_texture( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitWindowSize( 512, 512 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( argv[0] );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
// GLenum err = glewInit();
// if (GLEW_OK != err)
// {
// /* Problem: glewInit failed, something is seriously wrong. */
// fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
// exit( EXIT_FAILURE );
// }
// fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
texture_atlas_t * atlas = texture_atlas_new( 512, 512, 1 );
// const char *filename = "/Users/jie/svn/v8/deps/freetype-gl-read-only/fonts/Vera.ttf";
const char *filename = "/Users/jie/svn/v8/deps/freetype-gl-read-only/fonts/fat.ttf";
// const wchar_t *cache = L" !\"#$%&'()*+,-./0123456789:;<=>?"
// L"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
// L"`abcdefghijklmnopqrstuvwxyz{|}~";
wchar_t unicode[6];
unicode[0] = 22909;
unicode[1] = 20320;
unicode[2] = 25438;
unicode[3] = 28156;
unicode[4] = 48;
unicode[5] = 0;
wchar_t* cache = (wchar_t*)unicode;
printf("%d %d\n", cache[0], wcslen(cache));
size_t minsize = 20, maxsize = 40;
size_t count = maxsize - minsize;
size_t i, missed = 0;
for( i=minsize; i < maxsize; ++i )
{
texture_font_t * font = texture_font_new( atlas, filename, i );
missed += texture_font_load_glyphs( font, cache );
texture_font_delete( font );
}
printf( "Matched font : %s\n", filename );
printf( "Number of fonts : %ld\n", count );
printf( "Number of glyphs per font : %ld\n", wcslen(cache) );
printf( "Number of missed glyphs : %ld\n", missed );
printf( "Total number of glyphs : %ld/%ld\n", wcslen(cache)*count - missed, wcslen(cache)*count );
printf( "Texture size : %ldx%ld\n", atlas->width, atlas->height );
printf( "Texture occupancy : %.2f%%\n", 100.0*atlas->used/(float)(atlas->width*atlas->height) );
glClearColor(1,1,1,1);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, atlas->id );
typedef struct { float x,y,z, u,v, r,g,b,a; } vertex_t;
vertex_t vertices[4] = {
{ 0, 0, 0, 0,1, 0,0,0,1},
{ 0, 512,0, 0,0, 0,0,0,1},
{ 512,512,0, 1,0, 0,0,0,1},
{ 512, 0,0, 1,1, 0,0,0,1}
};
GLuint indices[6] = { 0,1,2, 0,2,3 };
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
vertex_buffer_push_back( buffer, vertices, 4, indices, 6 );
shader = shader_load("/Users/jie/svn/v8/deps/freetype-gl-read-only/shaders/v3f-t2f-c4f.vert",
"/Users/jie/svn/v8/deps/freetype-gl-read-only/shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop( );
return 0;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
#ifndef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
fprintf(stderr,
"This demo requires freetype to be compiled "
"with subpixel rendering.\n");
exit( EXIT_FAILURE) ;
#endif
glutInit( &argc, argv );
glutInitWindowSize( 260, 330 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( argv[0] );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
buffer = vertex_buffer_new( "vertex:3f,color:4f" );
vertex_t vertices[4*2] = { { 15, 0,0, 0,0,0,1},
{ 15,330,0, 0,0,0,1},
{245, 0,0, 0,0,0,1},
{245,330,0, 0,0,0,1}
};
GLuint indices[4*3] = { 0,1,2,3, };
vertex_buffer_push_back( buffer, vertices, 4, indices, 4 );
text_buffer = text_buffer_new( LCD_FILTERING_ON );
vec4 black = {{0.0, 0.0, 0.0, 1.0}};
text_buffer->base_color = black;
vec4 none = {{1.0, 1.0, 1.0, 0.0}};
markup_t markup;
markup.family = "fonts/Vera.ttf";
markup.size = 9.0;
markup.bold = 0;
markup.italic = 0;
markup.rise = 0.0;
markup.spacing = 0.0;
markup.gamma = 1.0;
markup.foreground_color = black;
markup.background_color = none;
markup.underline = 0;
markup.underline_color = black;
markup.overline = 0;
markup.overline_color = black;
markup.strikethrough = 0;
markup.strikethrough_color = black;
markup.font = 0;
size_t i;
vec2 pen = {{20, 320}};
wchar_t *text = L"| A Quick Brown Fox Jumps Over The Lazy Dog\n";
for( i=0; i < 30; ++i)
{
text_buffer_add_text( text_buffer, &pen, &markup, text, wcslen(text) );
pen.x += i*0.1;
}
shader = shader_load("shaders/v3f-c4f.vert",
"shaders/v3f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop( );
return 0;
}
// ------------------------------------------------------------------- init ---
void init( void )
{
size_t i;
atlas = texture_atlas_new( 512, 512, 1 );
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
vec4 white = {{1.0, 1.0, 1.0, 1.0}};
vec4 none = {{1.0, 1.0, 1.0, 0.0}};
markup_t markup;
markup.family = "../media/fonts/Vera.ttf";
markup.size = 80.0;
markup.bold = 0;
markup.italic = 0;
markup.rise = 0.0;
markup.spacing = 0.0;
markup.gamma = 1.5;
markup.foreground_color = white;
markup.background_color = none;
markup.underline = 0;
markup.underline_color = white;
markup.overline = 0;
markup.overline_color = white;
markup.strikethrough = 0;
markup.strikethrough_color = white;
markup.font = 0;
markup.font = texture_font_new_from_file( atlas, markup.size, "../media/fonts/Vera.ttf" );
markup.font->outline_type = 1;
vec2 pen;
pen.x = 40;
pen.y = 190;
for( i=0; i< 10; ++i)
{
markup.font->outline_thickness = 2*((i+1)/10.0);
add_text( buffer, &pen, &markup, "g", NULL );
}
pen.x = 40;
pen.y = 110;
markup.font->outline_type = 2;
for( i=0; i< 10; ++i)
{
markup.font->outline_thickness = 2*((i+1)/10.0);
add_text( buffer, &pen, &markup, "g", NULL );
}
pen.x = 40;
pen.y = 30;
markup.font->outline_type = 3;
for( i=0; i< 10; ++i)
{
markup.font->outline_thickness = 1*((i+1)/10.0);
add_text( buffer, &pen, &markup, "g", NULL );
}
shader = shader_load("../media/shaders/v3f-t2f-c4f.vert",
"../media/shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
GLFWwindow* window;
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 1, 1, "Glyph Cartoon", NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
atlas = texture_atlas_new( 1024, 1024, 1 );
buffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,color:4f" );
texture_font_t *font =
texture_font_new_from_file( atlas, 128, "fonts/LuckiestGuy.ttf" );
vec2 pen = {{50, 50}};
vec4 black = {{0.0, 0.0, 0.0, 1.0}};
vec4 yellow = {{1.0, 1.0, 0.0, 1.0}};
vec4 orange1 = {{1.0, 0.9, 0.0, 1.0}};
vec4 orange2 = {{1.0, 0.6, 0.0, 1.0}};
font->outline_type = 2;
font->outline_thickness = 7;
add_text( buffer, font, L"Freetype GL", pen, black, black );
font->outline_type = 2;
font->outline_thickness = 5;
add_text( buffer, font, L"Freetype GL", pen, yellow, yellow );
font->outline_type = 1;
font->outline_thickness = 3;
add_text( buffer, font, L"Freetype GL", pen, black, black );
font->outline_type = 0;
font->outline_thickness = 0;
add_text( buffer, font, L"Freetype GL", pen, orange1, orange2 );
shader = shader_load("shaders/v3f-t2f-c4f.vert",
"shaders/v3f-t2f-c4f.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glfwSetWindowSize( window, 850, 200 );
glfwShowWindow( window );
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
}
glfwDestroyWindow( window );
glfwTerminate( );
return 0;
}
// ------------------------------------------------------------------- init ---
void init( GLFWwindow* window )
{
// Create a new tweak bar
bar = TwNewBar("TweakBar");
TwDefine("GLOBAL "
"help = 'This example shows how to tune all font parameters.' ");
TwDefine("TweakBar "
"size = '280 400' "
"position = '500 20' "
"color = '127 127 127' "
"alpha = 240 "
"label = 'Parameters' "
"resizable = True "
"fontresizable = True "
"iconifiable = True ");
{
TwEnumVal familyEV[NUM_FONTS] = {
{VERA, "Vera"},
{VERA_MONO, "Vera Mono"},
{LUCKIEST_GUY, "Luckiest Guy"},
{SOURCE_SANS, "Source Sans Pro"},
{SOURCE_CODE, "Source Code Pro"},
{OLD_STANDARD, "Old Standard TT"},
{LOBSTER, "Lobster"} };
TwType family_type = TwDefineEnum("Family", familyEV, NUM_FONTS);
TwAddVarCB(bar, "Family", family_type, set_int, get_int, &p_family,
"label = 'Family' "
"group = 'Font' "
"help = ' ' ");
}
TwAddVarCB(bar, "Size", TW_TYPE_FLOAT, set_float, get_float, &p_size,
"label = 'Size' "
"group = 'Font' "
"min = 6.0 "
"max = 24.0 "
"step = 0.05 "
"help = ' ' ");
TwAddVarCB(bar, "LCD filtering", TW_TYPE_BOOL32, set_lcd_filtering, get_lcd_filtering, NULL,
"label = 'LCD filtering' "
"group = 'Font' "
"help = ' ' ");
// Rendering
TwAddVarCB(bar, "Kerning", TW_TYPE_BOOL32, set_int, get_int, &p_kerning,
"label = 'Kerning' "
"group = 'Rendering' "
"help = ' ' ");
TwAddVarCB(bar, "Hinting", TW_TYPE_BOOL32, set_int, get_int, &p_hinting,
"label = 'Hinting' "
"group = 'Rendering' "
"help = ' ' ");
// Color
TwAddVarCB(bar, "Invert", TW_TYPE_BOOL32, set_int, get_int, &p_invert,
"label = 'Invert' "
"group = 'Color' "
"help = ' ' ");
// Glyph
TwAddVarCB(bar, "Width", TW_TYPE_FLOAT, set_float, get_float, &p_width,
"label = 'Width' "
"group = 'Glyph' "
"min = 0.75 "
"max = 1.25 "
"step = 0.01 "
"help = ' ' ");
TwAddVarCB(bar, "Interval", TW_TYPE_FLOAT, set_float, get_float, &p_interval,
"label = 'Spacing' "
"group = 'Glyph' "
"min = -0.2 "
"max = 0.2 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Faux italic", TW_TYPE_FLOAT, set_float, get_float, &p_faux_italic,
"label = 'Faux italic' "
"group = 'Glyph' "
"min = -30.0 "
"max = 30.0 "
"step = 0.1 "
"help = ' ' ");
// Energy distribution
TwAddVarCB(bar, "Primary", TW_TYPE_FLOAT, set_float, get_float, &p_primary,
"label = 'Primary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Secondary", TW_TYPE_FLOAT, set_float, get_float, &p_secondary,
"label = 'Secondy weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Tertiary", TW_TYPE_FLOAT, set_float, get_float, &p_tertiary,
"label = 'Tertiary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddSeparator(bar, "",
"group = 'Energy distribution' " );
TwAddVarCB(bar, "Gamma", TW_TYPE_FLOAT, set_float, get_float, &p_gamma,
"label = 'Gamma correction' "
"group = 'Energy distribution' "
"min = 0.50 "
"max = 2.5 "
"step = 0.01 "
"help = ' ' ");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Reset", (TwButtonCallback) reset, NULL,
"help='Reset all parameters to default values.'");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Quit", (TwButtonCallback) quit, window,
"help='Quit.'");
text_shader = shader_load( "shaders/text.vert",
"shaders/text.frag" );
font_manager_a = font_manager_new( 512, 512, LCD_FILTERING_OFF );
font_manager_rgb = font_manager_new( 512, 512, LCD_FILTERING_ON );
font_manager = font_manager_rgb;
text_buffer = text_buffer_new( );
glGenTextures( 1, &font_manager_a->atlas->id );
glBindTexture( GL_TEXTURE_2D, font_manager_a->atlas->id );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glGenTextures( 1, &font_manager_rgb->atlas->id );
glBindTexture( GL_TEXTURE_2D, font_manager_rgb->atlas->id );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
reset();
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
// Main
int main(int argc, char *argv[])
{
GLFWwindow* window;
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 1, 1, "Font rendering advanced tweaking", NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
TwInit( TW_OPENGL, NULL );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetCursorPosCallback( window, cursor_pos );
glfwSetMouseButtonCallback( window, mouse_button );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
// Create a new tweak bar
bar = TwNewBar("TweakBar");
TwDefine("GLOBAL "
"help = 'This example shows how to tune all font parameters.' ");
TwDefine("TweakBar "
"size = '280 400' "
"position = '500 20' "
"color = '127 127 127' "
"alpha = 240 "
"label = 'Parameters' "
"resizable = True "
"fontresizable = True "
"iconifiable = True ");
{
TwEnumVal familyEV[NUM_FONTS] = {
{VERA, "Vera"},
{VERA_MONO, "Vera Mono"},
{LUCKIEST_GUY, "Luckiest Guy"},
{SOURCE_SANS, "Source Sans Pro"},
{SOURCE_CODE, "Source Code Pro"},
{OLD_STANDARD, "Old Standard TT"},
{LOBSTER, "Lobster"} };
TwType family_type = TwDefineEnum("Family", familyEV, NUM_FONTS);
TwAddVarCB(bar, "Family", family_type, set_family, get_family, NULL,
"label = 'Family' "
"group = 'Font' "
"help = ' ' ");
}
TwAddVarCB(bar, "Size", TW_TYPE_FLOAT, set_size, get_size, NULL,
"label = 'Size' "
"group = 'Font' "
"min = 6.0 "
"max = 24.0 "
"step = 0.05 "
"help = ' ' ");
TwAddVarCB(bar, "LCD filtering", TW_TYPE_BOOL32, set_lcd_filtering, get_lcd_filtering, NULL,
"label = 'LCD filtering' "
"group = 'Font' "
"help = ' ' ");
// Rendering
TwAddVarCB(bar, "Kerning", TW_TYPE_BOOL32, set_kerning, get_kerning, NULL,
"label = 'Kerning' "
"group = 'Rendering' "
"help = ' ' ");
TwAddVarCB(bar, "Hinting", TW_TYPE_BOOL32, set_hinting, get_hinting, NULL,
"label = 'Hinting' "
"group = 'Rendering' "
"help = ' ' ");
// Color
TwAddVarCB(bar, "Invert", TW_TYPE_BOOL32, set_invert, get_invert, NULL,
"label = 'Invert' "
"group = 'Color' "
"help = ' ' ");
// Glyph
TwAddVarCB(bar, "Width", TW_TYPE_FLOAT, set_width, get_width, NULL,
"label = 'Width' "
"group = 'Glyph' "
"min = 0.75 "
"max = 1.25 "
"step = 0.01 "
"help = ' ' ");
TwAddVarCB(bar, "Interval", TW_TYPE_FLOAT, set_interval, get_interval, NULL,
"label = 'Spacing' "
"group = 'Glyph' "
"min = -0.2 "
"max = 0.2 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Faux italic", TW_TYPE_FLOAT, set_faux_italic, get_faux_italic, NULL,
"label = 'Faux italic' "
"group = 'Glyph' "
"min = -30.0 "
"max = 30.0 "
"step = 0.1 "
"help = ' ' ");
// Energy distribution
TwAddVarCB(bar, "Primary", TW_TYPE_FLOAT, set_primary, get_primary, NULL,
"label = 'Primary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Secondary", TW_TYPE_FLOAT, set_secondary, get_secondary, NULL,
"label = 'Secondy weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Tertiary", TW_TYPE_FLOAT, set_tertiary, get_tertiary, NULL,
"label = 'Tertiary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddSeparator(bar, "",
"group = 'Energy distribution' " );
TwAddVarCB(bar, "Gamma", TW_TYPE_FLOAT, set_gamma, get_gamma, NULL,
"label = 'Gamma correction' "
"group = 'Energy distribution' "
"min = 0.50 "
"max = 2.5 "
"step = 0.01 "
"help = ' ' ");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Reset", (TwButtonCallback) reset, NULL,
"help='Reset all parameters to default values.'");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Quit", (TwButtonCallback) quit, window,
"help='Quit.'");
buffer_a = text_buffer_new( 1 );
buffer_rgb = text_buffer_new( 3 );
buffer = buffer_rgb;
reset();
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glfwSetWindowSize( window, 800, 600 );
glfwShowWindow( window );
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
}
TwTerminate();
glfwDestroyWindow( window );
glfwTerminate( );
return EXIT_SUCCESS;
}
void CFont::TextAdd(float x, float y, float _size, float rectw, float recth, const char *text, const unsigned length)
{
bool hasSizeChange = abs(_size - normal.size) > 0.01f;
bool hasTextChange = (0 == lasttext.size() || 0 != strcmp(text, lasttext.c_str()));
if (hasSizeChange || hasTextChange || nullptr == font_manager)
{
// DONE: rebuild a font texture and atlas
if (nullptr != font_manager)
{
glDeleteTextures(1, &font_manager->atlas->id);
font_manager->atlas->id = 0;
font_manager_delete(font_manager);
font_manager = nullptr;
}
normal.size = _size;
font_manager = font_manager_new(ATLAS_SIZE, ATLAS_SIZE, LCD_FILTERING_ON);
normal.font = font_manager_get_from_markup(font_manager, &normal);
normal.font->kerning = 0;
text_buffer_clear(buffer);
vec2 pen = { { 0, 0 } };
text_buffer_add_text(buffer, &pen, &normal, text, length);
//text_buffer_align(buffer, &pen, ALIGN_CENTER);
glGenTextures(1, &font_manager->atlas->id);
glBindTexture(GL_TEXTURE_2D, font_manager->atlas->id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, font_manager->atlas->width,
font_manager->atlas->height, 0, GL_RGB, GL_UNSIGNED_BYTE,
font_manager->atlas->data);
vec4 bounds = text_buffer_get_bounds(buffer, &pen);
mBounds[0] = bounds.x;
mBounds[1] = bounds.y;
mBounds[2] = bounds.z;
mBounds[3] = bounds.w;
lasttext = text;
}
//
//vec2 pen = { { x, y } };
//text_buffer_add_text(buffer, &pen, &normal, text, length);
mat4_set_identity(&model);
float stretch = 1.01f; // mBounds[2] / (0.8f * rectw);
float xoffset = 0.25f * mBounds[2] / length;
float yoffset = recth - 0.5f * (recth - mBounds[3]);
mat4_set_scaling(&model, stretch, 1.0f, 1.0f);
mat4_translate(&model, x + xoffset, y + yoffset, 0.0f);
}
