// ----------------------------------------------------------------------------
void
text_buffer_render( text_buffer_t * self )
{
glEnable( GL_BLEND );
glEnable( GL_TEXTURE_2D );
glColor4f( 1.0, 1.0, 1.0, 1.0);
if( self->manager->atlas->depth == 1 )
{
glDisable( GL_COLOR_MATERIAL );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
vertex_buffer_render( self->buffer, GL_TRIANGLES, "vtc" );
}
else
{
glEnable( GL_COLOR_MATERIAL );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
glBlendColor( 1.0, 1.0, 1.0, 1.0 );
glUseProgram( self->shader );
glUniform1i( self->shader_texture, 0 );
glUniform3f( self->shader_pixel,
1.0/self->manager->atlas->width,
1.0/self->manager->atlas->height,
self->manager->atlas->depth );
vertex_buffer_render( self->buffer, GL_TRIANGLES, "vtc" );
glUseProgram( 0 );
}
}
// ----------------------------------------------------------------------------
void
text_buffer_render( text_buffer_t * self )
{
texture_atlas_upload(&self->cache.atlas);
glEnable( GL_BLEND );
glEnable( GL_TEXTURE_2D );
glColor4f( 1.0, 1.0, 1.0, 1.0);
if( self->cache.atlas.depth == 1 ) {
glDisable( GL_COLOR_MATERIAL );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
vertex_buffer_render( self->buffer, GL_TRIANGLES, "vtc" );
} else {
glEnable( GL_COLOR_MATERIAL );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
glBlendColor( 1.0, 1.0, 1.0, 1.0 );
glUseProgram( self->shader );
glUniform1i( self->shader_texture, 0 );
glUniform3f( self->shader_pixel,
1.0/self->cache.atlas.size.x,
1.0/self->cache.atlas.size.y,
self->cache.atlas.depth );
vertex_buffer_render( self->buffer, GL_TRIANGLES, "vtc" );
glUseProgram( 0 );
}
}
// ---------------------------------------------------------------- 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 );
}
// ---------------------------------------------------------------- display ---
void display( void )
{
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glDisable( GL_BLEND );
glDisable( GL_TEXTURE_2D );
glColor4f(1,1,1,1);
glBegin(GL_QUADS);
glVertex2i(0,0);
glVertex2i(512,0);
glVertex2i(512,256);
glVertex2i(0,256);
glEnd();
glEnable( GL_BLEND );
glEnable( GL_TEXTURE_2D );
glEnable( GL_COLOR_MATERIAL );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
glUseProgram( program );
glUniform1i( texture_location, 0 );
glUniform2f( pixel_location, 1.0/atlas->width, 1.0/atlas->height );
vertex_buffer_render( buffer, GL_TRIANGLES, "vtc" );
glUseProgram( 0 );
glutSwapBuffers( );
}
// ---------------------------------------------------------------- display ---
void display( GLFWwindow* window )
{
static GLuint texture = 0;
if( !texture )
{
texture = glGetUniformLocation( shader, "texture" );
}
glClearColor( 0.40, 0.40, 0.45, 1.00 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_BLEND );
glEnable( GL_TEXTURE_2D );
glEnable( GL_COLOR_MATERIAL );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glUseProgram( shader );
{
glUniform1i( glGetUniformLocation( shader, "texture" ),
0 );
glUniformMatrix4fv( glGetUniformLocation( shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ),
1, 0, projection.data);
vertex_buffer_render( buffer, GL_TRIANGLES );
}
glfwSwapBuffers( window );
}
// ---------------------------------------------------------------- display ---
void display( void )
{
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glUseProgram( text_buffer->shader );
{
glUniformMatrix4fv( glGetUniformLocation( text_buffer->shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( text_buffer->shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( text_buffer->shader, "projection" ),
1, 0, projection.data);
text_buffer_render( text_buffer );
}
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
glBlendColor( 1.0, 1.0, 1.0, 1.0 );
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);
vertex_buffer_render( buffer, GL_LINES );
}
glutSwapBuffers( );
}
// ---------------------------------------------------------------- display ---
void display( void )
{
glClear( GL_COLOR_BUFFER_BIT );
glColor4f( 0.0f, 0.0f, 0.0f, 1.0f);
glUseProgram( program );
vertex_buffer_render( lines, GL_TRIANGLES, "vtc" );
glUseProgram( 0 );
glutSwapBuffers( );
}
// ---------------------------------------------------------------- display ---
void display( void )
{
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
vertex_buffer_render( buffer, GL_TRIANGLES, "vtc" );
glutSwapBuffers( );
}
// ---------------------------------------------------------------- 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_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_POINT_SMOOTH );
glEnable( GL_TEXTURE_2D );
glUseProgram( text_shader );
{
glUniform1i( glGetUniformLocation( text_shader, "texture" ),
0 );
glUniformMatrix4fv( glGetUniformLocation( text_shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( text_shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( text_shader, "projection" ),
1, 0, projection.data);
vertex_buffer_render( text_buffer, GL_TRIANGLES );
}
glDisable( GL_TEXTURE_2D );
glPointSize( 10.0f );
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);
vertex_buffer_render( line_buffer, GL_LINES );
vertex_buffer_render( point_buffer, GL_POINTS );
}
glUseProgram( 0 );
glutSwapBuffers( );
}
bool CFont::Display()
{
if (nullptr == font_manager || nullptr == buffer)
return false;
// TODO: check if we need to load a glsl shader
if (0 == text_shader)
{
FBString appPath;
appPath = FBSystem::TheOne().ApplicationPath;
appPath = appPath + "\\plugins";
FBString vert(appPath, SHADER_VERTEX);
FBString frag(appPath, SHADER_FRAGMENT);
text_shader = shader_load(vert, frag);
}
if (0 == text_shader)
return false;
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glUseProgram(text_shader);
{
glUniformMatrix4fv(glGetUniformLocation(text_shader, "model"),
1, 0, model.data);
glUniformMatrix4fv(glGetUniformLocation(text_shader, "view"),
1, 0, view.data);
glUniformMatrix4fv(glGetUniformLocation(text_shader, "projection"),
1, 0, projection.data);
glUniform1i(glGetUniformLocation(text_shader, "tex"), 0);
glUniform3f(glGetUniformLocation(text_shader, "pixel"),
1.0f / font_manager->atlas->width,
1.0f / font_manager->atlas->height,
(float)font_manager->atlas->depth);
glEnable(GL_BLEND);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, font_manager->atlas->id);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendColor(1, 1, 1, 1);
vertex_buffer_render(buffer->buffer, GL_TRIANGLES);
glBindTexture(GL_TEXTURE_2D, 0);
glBlendColor(0, 0, 0, 0);
glUseProgram(0);
glDisable(GL_BLEND);
}
return true;
}
// ---------------------------------------------------------------- display ---
void display( void )
{
static int frame=0, time, timebase=0;
static int count = 0;
if( count == 0 && frame == 0 )
{
printf(
"Computing FPS with text generation and rendering at each frame...\n" );
printf(
"Number of glyphs: %d\n", (int)wcslen(text)*line_count );
}
frame++;
time = glutGet( GLUT_ELAPSED_TIME );
if( time-timebase > (2500) )
{
printf( "FPS : %.2f (%d frames in %.2f second, %.1f glyph/second)\n",
frame*1000.0/(time-timebase), frame, (time-timebase)/1000.0,
frame*1000.0/(time-timebase) * wcslen(text)*line_count );
timebase = time;
frame = 0;
++count;
if( count == 5 )
{
printf( "\nComputing FPS with text rendering at each frame...\n" );
printf( "Number of glyphs: %d\n", (int)wcslen(text)*line_count );
}
if( count > 9 )
{
exit( EXIT_SUCCESS );
}
}
if( count < 5 )
{
size_t i;
vec4 color = {{0,0,0,1}};
vec2 pen = {{0,0}};
vertex_buffer_clear( buffer );
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;
}
}
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glColor4f( 0,0,0,1 );
glBindTexture( GL_TEXTURE_2D, atlas->id );
vertex_buffer_render( buffer, GL_TRIANGLES, "vtc" );
glutSwapBuffers( );
}
void FontRenderer::RenderText(unsigned int x, unsigned int y, const char* pText)
{
bool IsCullEnabled = glIsEnabled(GL_CULL_FACE);
glDisable(GL_CULL_FACE);
assert(strlen(pText) < MAX_STRING_LEN);
wchar_t text[MAX_STRING_LEN] = { 0 };
int len = mbstowcs(text, pText, strlen(pText));
assert(len > 0);
vertex_buffer_clear( m_pTextBuffer );
TextureGlyph* pGlyph = texture_font_get_glyph( m_pFont, text[0] );
assert(pGlyph);
Pen pen = {(float)x, (float)y};
texture_glyph_add_to_vertex_buffer( pGlyph, m_pTextBuffer, &markup, &pen, 0 );
for( size_t i=1; i<wcslen(text); ++i )
{
pGlyph = texture_font_get_glyph( m_pFont, text[i] );
assert(pGlyph);
int kerning = texture_glyph_get_kerning( pGlyph, text[i-1] );
texture_glyph_add_to_vertex_buffer( pGlyph, m_pTextBuffer, &markup, &pen, kerning );
}
glActiveTexture(GL_TEXTURE0);
glBindTexture( GL_TEXTURE_2D, m_pManager->atlas->texid );
m_fontShader.Enable();
int viewport[4];
glGetIntegerv( GL_VIEWPORT, viewport );
float xScale = 2.0f / (float)viewport[2];
float yScale = 2.0f / (float)viewport[3];
GLfloat Trans[] = { xScale, 0.0f, 0.0f, -1.0f,
0.0f, yScale, 0.0f, -1.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f };
m_fontShader.SetTransformation(Trans);
vertex_buffer_render( m_pTextBuffer, GL_TRIANGLES, "vtc" );
if (IsCullEnabled) {
glEnable(GL_CULL_FACE);
}
}
// ---------------------------------------------------------------- display ---
void display( void )
{
glClearColor( 0.40, 0.40, 0.45, 1.00 );
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_BLEND );
glEnable( GL_TEXTURE_2D );
glEnable( GL_COLOR_MATERIAL );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
vertex_buffer_render( buffer, GL_TRIANGLES, "vtc" );
glutSwapBuffers( );
}
void Font::Draw2D(const Vector2Df& pos, const char* text)
{
add_text(m_buffer, m_font, m_fontFile->m_buffer, m_fontFile->m_bufLength, text, ((vec2*)&pos), m_currentSize);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
m_glProgram->SetModelViewProjection();
m_glProgram->SetUnifromTexture("diffuseMap", m_textureAtlas);
m_glProgram->UseProgram();
vertex_buffer_render(m_buffer, GL_TRIANGLES);
vertex_buffer_clear(m_buffer);
}
// ---------------------------------------------------------------- display ---
void display( void )
{
static float theta=0, phi=0;
static GLuint Color = 0;
float seconds_elapsed = (float)clock() / CLOCKS_PER_SEC;
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 );
glPushMatrix();
glRotatef( theta, 0,0,1 );
glRotatef( phi, 0,1,0 );
glDisable( GL_BLEND );
glEnable( GL_DEPTH_TEST );
glEnable( GL_POLYGON_OFFSET_FILL );
glUseProgram( shader );
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 );
glPopMatrix();
glutSwapBuffers( );
}
// ---------------------------------------------------------------- display ---
static void display( void )
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glUseProgram( shader );
{
glUniform1i( glGetUniformLocation( shader, "texture" ), 0 );
glUniformMatrix4fv( glGetUniformLocation( shader, "model" ), 1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "view" ), 1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ), 1, 0, projection.data);
vertex_buffer_render( buffer, GL_TRIANGLES );
}
glutSwapBuffers( );
}
// ---------------------------------------------------------------- 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_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_TEXTURE_2D );
glColor4f(1,1,1,1);
glPushMatrix();
glTranslatef(5, viewport[3], 0);
vertex_buffer_render( buffer, GL_TRIANGLES, "vtc" );
glPopMatrix();
glutSwapBuffers( );
}
// ---------------------------------------------------------------- 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( 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 )
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glUseProgram( shader );
{
glUniform1i( glGetUniformLocation( shader, "texture" ), 0 );
glUniform3f( glGetUniformLocation( shader, "pixel" ), 1/512., 1/512., 1.0f );
glUniformMatrix4fv( glGetUniformLocation( shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ),
1, 0, projection.data);
vertex_buffer_render( vbuffer, GL_TRIANGLES );
}
glfwSwapBuffers( window );
}
// ---------------------------------------------------------------- display ---
void display( GLFWwindow* window )
{
if( !p_invert )
{
glClearColor( 0, 0, 0, 1 );
}
else
{
glClearColor( 1, 1, 1, 1 );
}
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glUseProgram( text_shader );
{
glUniformMatrix4fv( glGetUniformLocation( text_shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( text_shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( text_shader, "projection" ),
1, 0, projection.data);
glUniform1i( glGetUniformLocation( text_shader, "tex" ), 0 );
glUniform3f( glGetUniformLocation( text_shader, "pixel" ),
1.0f/font_manager->atlas->width,
1.0f/font_manager->atlas->height,
(float)font_manager->atlas->depth );
glEnable( GL_BLEND );
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, font_manager->atlas->id );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glBlendColor( 1, 1, 1, 1 );
vertex_buffer_render( text_buffer->buffer, GL_TRIANGLES );
glBindTexture( GL_TEXTURE_2D, 0 );
glBlendColor( 0, 0, 0, 0 );
glUseProgram( 0 );
}
TwDraw( );
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 );
float alpha = 1;
glEnable( GL_COLOR_MATERIAL );
glBlendFunc( GL_CONSTANT_COLOR_EXT,
GL_ONE_MINUS_SRC_COLOR );
glEnable( GL_BLEND );
glColor3f( alpha, alpha, alpha );
glBlendColor( 1-alpha, 1-alpha, 1-alpha, 1 );
glEnable( GL_TEXTURE_2D );
glPushMatrix();
glTranslatef(5, viewport[3], 0);
vertex_buffer_render( buffer, GL_TRIANGLES, "vtc" );
glPopMatrix();
glutSwapBuffers( );
}
// ----------------------------------------------------------------------------
void
text_buffer_render( text_buffer_t * self )
{
glEnable( GL_BLEND );
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, self->manager->atlas->id );
if( self->manager->atlas->depth == 1 )
{
//glDisable( GL_COLOR_MATERIAL );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glBlendColor( 1, 1, 1, 1 );
}
else
{
//glEnable( GL_COLOR_MATERIAL );
//glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
//glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
//glBlendColor( 1.0, 1.0, 1.0, 1.0 );
//glBlendFunc( GL_CONSTANT_COLOR_EXT, GL_ONE_MINUS_SRC_COLOR );
//glBlendColor( self->base_color.r,
//self->base_color.g,
//self->base_color.b,
//self->base_color.a );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glBlendColor( 1, 1, 1, 1 );
}
glUseProgram( self->shader );
glUniform1i( self->shader_texture, 0 );
glUniform3f( self->shader_pixel,
1.0/self->manager->atlas->width,
1.0/self->manager->atlas->height,
self->manager->atlas->depth );
vertex_buffer_render( self->buffer, GL_TRIANGLES );
glBindTexture( GL_TEXTURE_2D, 0 );
glBlendColor( 0, 0, 0, 0 );
glUseProgram( 0 );
}
// ---------------------------------------------------------------- display ---
void display( void )
{
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 );
glUseProgram( shader );
{
glUniform1i( glGetUniformLocation( shader, "texture" ),
0 );
glUniformMatrix4fv( glGetUniformLocation( shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ),
1, 0, projection.data);
vertex_buffer_render( buffer, GL_TRIANGLES );
}
glutSwapBuffers( );
}
// ---------------------------------------------------------------- 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( );
}
// ---------------------------------------------------------------- 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 );
float alpha = 1;
glEnable( GL_TEXTURE_2D );
glEnable( GL_COLOR_MATERIAL );
glBlendFunc( GL_CONSTANT_COLOR_EXT,
GL_ONE_MINUS_SRC_COLOR );
glEnable( GL_BLEND );
glColor3f( alpha, alpha, alpha );
glBlendColor( 1-alpha, 1-alpha, 1-alpha, 1 );
glEnable( GL_TEXTURE_2D );
glUseProgram( program );
glUniform1i( texture_location, 0 );
glUniform2f( pixel_location,
1.0/atlas->width,
1.0/atlas->height );
vertex_buffer_render( buffer, GL_TRIANGLES, "vtc" );
glUseProgram( 0 );
glDisable( GL_BLEND );
glDisable( GL_TEXTURE_2D );
glColor4f(0,0,0,1);
glBegin(GL_LINES);
glVertex2i(15,0);
glVertex2i(15, 330);
glVertex2i(245, 0);
glVertex2i(245, 330);
glEnd();
glutSwapBuffers( );
}
// ---------------------------------------------------------------- display ---
void display( GLFWwindow* window )
{
static int frame=0;
static int count = 0;
static double time;
if( count == 0 && frame == 0 )
{
printf(
"Computing FPS with text generation and rendering at each frame...\n" );
printf(
"Number of glyphs: %d\n", (int)strlen(text)*line_count );
}
frame++;
time = glfwGetTime( );
if( time > 2.5 )
{
printf( "FPS : %.2f (%d frames in %.2f second, %.1f glyph/second)\n",
frame/time, frame, time,
frame/time * strlen(text)*line_count );
glfwSetTime( 0.0 );
frame = 0;
++count;
if( count == 5 )
{
printf( "\nComputing FPS with text rendering at each frame...\n" );
printf( "Number of glyphs: %d\n", (int)strlen(text)*line_count );
}
if( count > 9 )
{
glfwSetWindowShouldClose( window, GL_TRUE );
}
}
if( count < 5 )
{
size_t i;
vec4 color = {{0,0,0,1}};
vec2 pen = {{0,0}};
vertex_buffer_clear( buffer );
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;
}
}
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glBindTexture( GL_TEXTURE_2D, atlas->id );
glUseProgram( shader );
{
glUniform1i( glGetUniformLocation( shader, "texture" ),
0 );
glUniformMatrix4fv( glGetUniformLocation( shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ),
1, 0, projection.data);
vertex_buffer_render( buffer, GL_TRIANGLES );
}
glfwSwapBuffers( window );
}
size_t
sen_render_flush(int clear_buff)
{
// gl_check_error();
//_logfi("1");
blend_group_t* bg;
khint_t i,k,j;
size_t total = 0;
khash_t(hmsp)* tgs;
camera_t* cam = sen_camera();
tex_group_t* tg;
khash_t(hmsp)* sgs;
shader_group_t* sg;
vector_clear(zsorter);
for (k = kh_begin(g_bgs); k != kh_end(g_bgs); ++k)
{
if (!kh_exist(g_bgs,k)) continue;
bg = kh_val(g_bgs, k);
if (bg->num == 0) {
kh_del(hmip,g_bgs,k);
continue;
}
tgs = bg->tgs;
// set_blending( (blend_func) (kh_key(g_bgs, k)) );
for (i = kh_begin(tgs); i != kh_end(tgs); ++i)
{
if (!kh_exist(tgs,i)) continue;
tg = kh_val(tgs, i);
if (tg->num == 0) {
kh_del(hmsp,tgs,i);
continue;
}
/*
if (tg->tex)
sen_texture_bind(tg->tex);
else if (tg->font)
sen_font_bind(tg->font);
*/
sgs = tg->sgs;
for (j = kh_begin(sgs); j != kh_end(sgs); ++j)
{
if (!kh_exist(sgs,j)) continue;
sg = kh_val(sgs, j);
if (sg->num == 0 || !sg->buff) {
kh_del(hmsp,sgs,j);
continue;
}
if (sg->buff) {
/*
sen_shader_use(sg->program);
{
if (tg->tex || tg->font)
sen_uniform_1iN(sg->program, "u_tex0", 0);
sen_uniform_m4fN(sg->program, "u_mvp", cam->view_proj.data);
vertex_buffer_render( sg->buff, GL_TRIANGLES);
total+=vertex_buffer_size(sg->buff);
if (clear_buff)
vertex_buffer_clear( sg->buff );
//sen_shader_use(NULL);
}*/
vector_push_back( zsorter, &sg );
}
sg->num = 0;
}
tg->num = 0;
}
bg->num = 0;
}
if (zsorter->size > 0)
vector_sort(zsorter, zcmp);
for (j = 0; j < zsorter->size; j++) {
shader_group_t* sg = *(shader_group_t**)vector_get(zsorter, j);
// _logfi("%s %d",sg->name, sg->z);
set_blending( (blend_func) (sg->bg->key) );
if (sg->tg->tex)
sen_texture_bind(sg->tg->tex);
else if (sg->tg->font)
sen_font_bind(sg->tg->font);
sen_shader_use(sg->program);
{
if (sg->tg->tex || sg->tg->font)
sen_uniform_1iN(sg->program, "u_tex0", 0);
sen_uniform_m4fN(sg->program, "u_mvp", sg->z > 9500 ? cam->proj.data : cam->view_proj.data);
vertex_buffer_render( sg->buff, GL_TRIANGLES);
total+=vertex_buffer_size(sg->buff);
if (clear_buff)
vertex_buffer_clear( sg->buff );
//sen_shader_use(NULL);
}
}
// _logfi("-------------------------------------------------");
return total;
}
// ----------------------------------------------------------- build_buffer ---
void
build_buffer( void )
{
vec2 pen;
size_t i;
texture_font_t *font;
texture_glyph_t *glyph;
vec4 white = {{1.0, 1.0, 1.0, 1.0}};
vec4 none = {{1.0, 1.0, 1.0, 0.0}};
markup_t markup = {
.family = "Arial",
.size = 10.0,
.bold = 0,
.italic = 0,
.rise = 0.0,
.spacing = 0.0,
.gamma = 2.2,
.foreground_color = white,
.background_color = none,
.underline = 0,
.underline_color = white,
.overline = 0,
.overline_color = white,
.strikethrough = 0,
.strikethrough_color = white,
.font = 0,
};
vertex_buffer_clear( buffer );
texture_atlas_clear( atlas );
if( p_family == VERA)
{
font = texture_font_new( atlas, "fonts/Vera.ttf", p_size );
}
else if( p_family == VERA_MONO)
{
font = texture_font_new( atlas, "fonts/VeraMono.ttf", p_size );
}
else if( p_family == GEORGIA)
{
font = texture_font_new( atlas, "fonts/Georgia.ttf", p_size );
}
else if( p_family == TIMES )
{
font = texture_font_new( atlas, "fonts/Times.ttf", p_size );
}
else if( p_family == TAHOMA )
{
font = texture_font_new( atlas, "fonts/Tahoma.ttf", p_size );
}
else if( p_family == ARIAL )
{
font = texture_font_new( atlas, "fonts/Arial.ttf", p_size );
}
else if( p_family == VERDANA )
{
font = texture_font_new( atlas, "fonts/Verdana.ttf", p_size );
}
else
{
fprintf( stderr, "Error : Unknown family type\n" );
return;
}
font->hinting = p_hinting;
font->filtering = 1;
float norm = 1.0/(p_primary + 2*p_secondary + 2*p_tertiary);
font->lcd_weights[0] = (unsigned char)(p_tertiary*norm*256);
font->lcd_weights[1] = (unsigned char)(p_secondary*norm*256);
font->lcd_weights[2] = (unsigned char)(p_primary*norm*256);
font->lcd_weights[3] = (unsigned char)(p_secondary*norm*256);
font->lcd_weights[4] = (unsigned char)(p_tertiary*norm*256);
texture_font_load_glyphs( font,
L" !\"#$%&'()*+,-./0123456789:;<=>?"
L"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
L"`abcdefghijklmnopqrstuvwxyz{|}~" );
pen.x = 10;
pen.y = 600 - font->height - 10;
glyph = texture_font_get_glyph( font, text[0] );
add_glyph( glyph, buffer, &markup, &pen, 0 );
for( i=1; i<wcslen(text); ++i )
{
if( text[i] == '\n' )
{
pen.x = 10;
pen.y -= font->height; // + 0.01*(size - (int)size)*font->height;
}
else
{
glyph = texture_font_get_glyph( font, text[i] );
float kerning = 0.0;
if( p_kerning )
{
kerning = texture_glyph_get_kerning( glyph, text[i-1] );
}
add_glyph( glyph, buffer, &markup, &pen, kerning );
}
}
texture_font_delete (font );
}
// ---------------------------------------------------------------- display ---
void display(void)
{
if( p_invert )
{
glClearColor( 0, 0, 0, 1 );
}
else
{
glClearColor( 1, 1, 1, 1 );
}
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, atlas->id );
if( !p_lcd_filtering )
{
glEnable( GL_COLOR_MATERIAL );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
if( p_invert )
{
glColor4f(1,1,1,1);
}
else
{
glColor4f(0,0,0,1);
}
}
else
{
glEnable( GL_COLOR_MATERIAL );
glBlendFunc( GL_CONSTANT_COLOR_EXT,
GL_ONE_MINUS_SRC_COLOR );
glEnable( GL_BLEND );
glColor3f( 1,1,1 );
if( p_invert )
{
glBlendColor( 1, 1, 1, 1 );
}
else
{
glBlendColor( 0, 0, 0, 1 );
}
}
if( !p_lcd_filtering )
{
vertex_buffer_render( buffer, GL_TRIANGLES, "vt" );
}
else
{
glUseProgram( program );
glUniform1i( texture_location, 0 );
glUniform1f( gamma_location, p_gamma );
float norm = 1.0/(p_primary+2*p_secondary+2*p_tertiary);
glUniform1f( primary_location, p_primary*norm );
glUniform1f( secondary_location, p_secondary*norm );
glUniform1f( tertiary_location, p_tertiary*norm );
glUniform2f( pixel_location,
1.0/atlas->width,
1.0/atlas->height );
vertex_buffer_render( buffer, GL_TRIANGLES, "vtc" );
glUseProgram( 0 );
}
TwDraw( );
glutSwapBuffers( );
}
// ---------------------------------------------------------------- reshape ---
void reshape( int width, int height )
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, width, 0, height, -1, 1);
glMatrixMode(GL_MODELVIEW);
TwWindowSize( width, height );
}
// -------------------------------------------------------- console_render ---
void
console_render( console_t *self )
{
int viewport[4];
glGetIntegerv( GL_VIEWPORT, viewport );
size_t i, index;
self->pen.x = 0;
self->pen.y = viewport[3];
vertex_buffer_clear( console->buffer );
int cursor_x = self->pen.x;
int cursor_y = self->pen.y;
markup_t markup;
// console_t buffer
markup = self->markup[MARKUP_FAINT];
self->pen.y -= markup.font->height;
for( i=0; i<self->lines->size; ++i )
{
wchar_t *text = * (wchar_t **) vector_get( self->lines, i ) ;
if( wcslen(text) > 0 )
{
console_add_glyph( console, text[0], L'\0', &markup );
for( index=1; index < wcslen(text)-1; ++index )
{
console_add_glyph( console, text[index], text[index-1], &markup );
}
}
self->pen.y -= markup.font->height - markup.font->linegap;
self->pen.x = 0;
cursor_x = self->pen.x;
cursor_y = self->pen.y;
}
// Prompt
markup = self->markup[MARKUP_BOLD];
if( wcslen( self->prompt ) > 0 )
{
console_add_glyph( console, self->prompt[0], L'\0', &markup );
for( index=1; index < wcslen(self->prompt); ++index )
{
console_add_glyph( console, self->prompt[index], self->prompt[index-1], &markup );
}
}
cursor_x = (int) self->pen.x;
// Input
markup = self->markup[MARKUP_NORMAL];
if( wcslen(self->input) > 0 )
{
console_add_glyph( console, self->input[0], L'\0', &markup );
if( self->cursor > 0)
{
cursor_x = (int) self->pen.x;
}
for( index=1; index < wcslen(self->input); ++index )
{
console_add_glyph( console, self->input[index], self->input[index-1], &markup );
if( index < self->cursor )
{
cursor_x = (int) self->pen.x;
}
}
}
// Cursor (we use the black character (-1) as texture )
texture_glyph_t *glyph = texture_font_get_glyph( markup.font, -1 );
float r = markup.foreground_color.r;
float g = markup.foreground_color.g;
float b = markup.foreground_color.b;
float a = markup.foreground_color.a;
int x0 = cursor_x+1;
int y0 = cursor_y + markup.font->descender;
int x1 = cursor_x+2;
int y1 = y0 + markup.font->height - markup.font->linegap;
float s0 = glyph->s0;
float t0 = glyph->t0;
float s1 = glyph->s1;
float t1 = glyph->t1;
GLuint indices[] = {0,1,2, 0,2,3};
vertex_t vertices[] = { { x0,y0,0, s0,t0, r,g,b,a },
{ x0,y1,0, s0,t1, r,g,b,a },
{ x1,y1,0, s1,t1, r,g,b,a },
{ x1,y0,0, s1,t0, r,g,b,a } };
vertex_buffer_push_back( self->buffer, vertices, 4, indices, 6 );
glEnable( GL_TEXTURE_2D );
glUseProgram( shader );
{
glUniform1i( glGetUniformLocation( shader, "texture" ),
0 );
glUniformMatrix4fv( glGetUniformLocation( shader, "model" ),
1, 0, model.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "view" ),
1, 0, view.data);
glUniformMatrix4fv( glGetUniformLocation( shader, "projection" ),
1, 0, projection.data);
vertex_buffer_render( console->buffer, GL_TRIANGLES );
}
}
