example/example.cpp

Go to the documentation of this file.

#include <GL/glut.h>

#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <fstream>

#include "faogenlib.h"

struct plane_vertex
{
        float pos[3];
        float normal[3];
        GLubyte color[4];       
};

int const plane_size = 100;
plane_vertex plane_geometry[plane_size*plane_size];
unsigned short plane_indices[(plane_size-1)*(plane_size-1)*2*3];

void build_plane();

float cube_vertices[] = 
{
        -0.5f, -0.5f, 0.f,
        0.5f, -0.5f, 0.f,
        -0.5f, 0.5f, 0.f,
        0.5f, 0.5f, 0.f,
        -0.5f, -0.5f, 1.f,
        0.5f, -0.5f, 1.f,
        -0.5f, 0.5f, 1.f,
        0.5f, 0.5f, 1.f,
        -0.5f, -0.5f, 1.f,
        0.5f, -0.5f, 1.f,
        -0.5f, 0.5f, 1.f,
        0.5f, 0.5f, 1.f,
        -0.5f, -0.5f, 0.f,
        0.5f, -0.5f, 0.f,
        -0.5f, -0.5f, 1.f,
        0.5f, -0.5f, 1.f,
        -0.5f, -0.5f, 0.f,
        -0.5f, 0.5f, 0.f,
        -0.5f, 0.5f, 1.f,
        -0.5f, 0.5f, 0.f,
        0.5f, 0.5f, 0.f,
        0.5f, 0.5f, 1.f,
        0.5f, -0.5f, 0.f,
        0.5f, 0.5f, 0.f
};

float cube_texcoords[] = 
{
        0.3360113f, 1.f, 
        0.f, 0.6720225f, 
        0.3360113f, 0.6720225f, 
        0.3279775f, 0.6720225f, 
        0.6639888f, 0.3279775f, 
        0.f, 1.f, 
        0.3279775f, 0.3279775f, 
        0.3279775f, 1.f, 
        0.f, 0.3360113f, 
        0.3279775f, 0.3360113f, 
        0.f, 0.6639888f, 
        0.3279775f, 0.6639888f, 
        0.3360113f, 0.3360113f, 
        0.6639888f, 0.3360113f, 
        0.3360113f, 0.6639888f, 
        0.6639888f, 0.6639888f, 
        0.6639888f, 0.f, 
        0.3360113f, 0.f, 
        0.3360113f, 0.3279775f, 
        0.3279775f, 0.f, 
        0.f, 0.f, 
        0.f, 0.3279775f, 
        0.6639888f, 1.f, 
        0.6639888f, 0.6720225f
};

float cube_normals[] = 
{
        0.f, 0.f, -1.f,
        1.f, 0.f, 0.f,
        0.f, 0.f, -1.f,
        1.f, 0.f, 0.f,
        -1.f, 0.f, 0.f,
        1.f, 0.f, 0.f,
        0.f, 1.f, 0.f,
        1.f, 0.f, 0.f,
        0.f, 0.f, 1.f,
        0.f, 0.f, 1.f,
        0.f, 0.f, 1.f,
        0.f, 0.f, 1.f,
        0.f, -1.f, 0.f,
        0.f, -1.f, 0.f,
        0.f, -1.f, 0.f,
        0.f, -1.f, 0.f,
        -1.f, 0.f, 0.f,
        -1.f, 0.f, 0.f,
        -1.f, 0.f, 0.f,
        0.f, 1.f, 0.f,
        0.f, 1.f, 0.f,
        0.f, 1.f, 0.f,
        0.f, 0.f, -1.f,
        0.f, 0.f, -1.f, 
};

unsigned short cube_indices[6*2*3] = 
{
        1-1, 3-1, 24-1,
        24-1, 23-1, 1-1,
        9-1, 10-1, 12-1,
        12-1, 11-1, 9-1,
        13-1, 14-1, 16-1,
        16-1, 15-1, 13-1,
        2-1, 4-1, 8-1,
        8-1, 6-1, 2-1,
        21-1, 20-1, 7-1,
        7-1, 22-1, 21-1,
        18-1, 17-1, 5-1,
        5-1, 19-1, 18-1,
};

float cube_matrix[16] = 
{
        0.8639584f, -0.5035632f, 0.f, 0.f,
        0.5035632f, 0.8639584f, 0.f, 0.f,
        0.f, 0.f, 1.f, 0.f, 
        0.f, 0.f, -0.25f, 1.f
};

GLuint cube_texture = 0;

float bottom_occludder[] = 
{
        -5.f, -5.f, 0.f,
        5.f, -5.f, 0.f,
        -5.f, 5.f, 0.f,
        5.f, 5.f, 0.f,
        0.f, 0.f, -5.f,
};

unsigned short bottom_indices[] = 
{
        0, 4, 1,
        1, 4, 3,
        3, 4, 2,
        2, 4, 0
};

bool generate_example()
{
        // First we need to initialize faogenlib
        if( faogenlib::initialize() )
        {
                // Now define scene:

                // plane object - horizontal grid, for which per-vertex AO will be calculated
                faogenlib::obj_handle plane = faogenlib::create_object_vn( 
                        &plane_geometry[0].pos[0], sizeof(plane_vertex),
                        &plane_geometry[0].normal[0], sizeof(plane_vertex), 
                        sizeof(plane_geometry)/sizeof(plane_geometry[0]),
                        faogenlib::INDEX_U16, plane_indices, sizeof(plane_indices)/sizeof(plane_indices[0]) );

                // cube - contains texcoords
                faogenlib::obj_handle cube = faogenlib::create_object_vnt( 
                        cube_vertices, 3*sizeof(float),
                        cube_normals, 3*sizeof(float), 
                        cube_texcoords, 2*sizeof(float),
                        24,
                        faogenlib::INDEX_U16, cube_indices, sizeof(cube_indices)/sizeof(cube_indices[0]) );

                // faogenlib allows to change transformation matrix for any object in scene
                faogenlib::set_object_matrix( cube, cube_matrix );

                // bottom geometry - only vertex positions
                faogenlib::obj_handle bottom = faogenlib::create_object_v( 
                        bottom_occludder, 3*sizeof(float),
                        5,
                        faogenlib::INDEX_U16, bottom_indices, sizeof(bottom_indices)/sizeof(bottom_indices[0]) );

                unsigned int const quality = 10;
                unsigned int iterations = faogenlib::num_iterations( quality );
                unsigned int step = iterations/50;
                if( step == 0 )
                        step = 1;

                unsigned int texture_size = 256;
                
                // generate AO texture for cube
                if( faogenlib::start_ao_gen_tex( cube, 1024, 0.01f, 1.f, quality, true, texture_size, texture_size, 2, false ) )
                {
                        std::cout << "cube\t:";
                        do
                        {
                                faogenlib::ao_tex_generate( step );
                                std::cout << '.';
                        }
                        while( !faogenlib::results_ready() );

                        float const * result = faogenlib::get_tex_results( 16 );

                        glGenTextures( 1, &cube_texture );
                        glBindTexture( GL_TEXTURE_2D, cube_texture );
                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0x812F/*GL_CLAMP_TO_EDGE*/ );
                        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 0x812F/*GL_CLAMP_TO_EDGE*/ );
                        glTexImage2D( GL_TEXTURE_2D, 0, GL_LUMINANCE8, texture_size, texture_size, 0, GL_LUMINANCE, GL_FLOAT, result );

                        std::cout << "done\n";
                }

                // generate per-vertex AO for plane
                if( faogenlib::start_ao_gen_vert( plane, 1024, 0.01f, 1.f, quality, true, 2, false ) )
                {
                        std::cout << "plane\t:";
                        do
                        {
                                faogenlib::ao_vert_generate( step );
                                std::cout << '.';
                        }
                        while( !faogenlib::results_ready() );

                        float const * result = faogenlib::get_vert_results();
                        for( int i = 0; i < sizeof(plane_geometry)/sizeof(plane_geometry[0]); i++ )
                        {
                                unsigned char value = result[i] < 0.f ? 0 : result[i] > 1.f ? 255 : (unsigned char)(result[i]*255.f);
                                plane_geometry[i].color[0] = value;
                                plane_geometry[i].color[1] = value;
                                plane_geometry[i].color[2] = value;
                                plane_geometry[i].color[3] = 255;
                        }

                        std::cout << "done\n";
                }

                faogenlib::shutdown();
                return true;
        }
        return false;
}

void build_plane()
{
        plane_vertex * v = plane_geometry;
        for( int j = 0; j < plane_size; j++ )
        {
                float y = ( float(j)/float(plane_size-1) - 0.5f )*10.f;
                for( int i = 0; i < plane_size; i++ )
                {
                        float x = ( float(i)/float(plane_size-1) - 0.5f )*10.f;
                        v->pos[0] = x;
                        v->pos[1] = y;
                        v->pos[2] = 0.f;
                        v->normal[0] = 0.f;
                        v->normal[1] = 0.f;
                        v->normal[2] = 1.f;
                        v->color[0] = 0;
                        v->color[1] = 0;
                        v->color[2] = 0;
                        v->color[3] = 0;
                        v++;
                }
        }

        unsigned short * idx = plane_indices;
        for( int j = 0; j < plane_size-1; j++ )
        {
                for( int i = 0; i < plane_size-1; i++ )
                {
                        *idx++ = (unsigned short)(j*plane_size + i);
                        *idx++ = (unsigned short)((j+1)*plane_size + i+1);
                        *idx++ = (unsigned short)((j+1)*plane_size + i);
                        *idx++ = (unsigned short)(j*plane_size + i);
                        *idx++ = (unsigned short)(j*plane_size + i+1);
                        *idx++ = (unsigned short)((j+1)*plane_size + i+1);
                }
        }
}

void reshape( int w, int h )
{
        glViewport( 0, 0, w, h );
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();
        gluPerspective( 60., double(w)/double(h), 0.5, 100. );
        glMatrixMode( GL_MODELVIEW );
}

void key( unsigned char key, int x, int y )
{
        switch( key )
        {
        case '\033':    // Escape
                glDeleteTextures( 1, &cube_texture );
                std::exit( 0 );
                break;
        }
}

void idle()
{
        static float angle = 0.f;
        static float t = 0.f;
        t += 0.001f;
        if( t > 2.f*3.14159265358979323846f )
                t = 0.f;

        angle += 0.01f;
        if( angle >= 360.f )
                angle = 0.f;
        glLoadIdentity();
        glTranslatef( 0.f, 0.f, -8.f );
        glRotatef( (1.f + sinf( t ))*0.5f*-45.f-45.f, 1.f, 0.f, 0.f );
        glRotatef( angle, 0.f, 0.f, 1.f );

        glutPostRedisplay();
}

void display()
{
        glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );

        glEnableClientState( GL_VERTEX_ARRAY );
        glVertexPointer( 3, GL_FLOAT, sizeof(plane_vertex), &plane_geometry[0].pos[0] );

        glEnableClientState( GL_COLOR_ARRAY );
        glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(plane_vertex), &plane_geometry[0].color[0] );

        glDrawElements( GL_TRIANGLES, 
                sizeof(plane_indices)/sizeof(plane_indices[0]), GL_UNSIGNED_SHORT, plane_indices );

        glDisableClientState( GL_COLOR_ARRAY );

        glColor3f( 1.f, 1.f, 1.f );

        glEnable( GL_TEXTURE_2D );
        glPushMatrix();
        glMultMatrixf( cube_matrix );

        glVertexPointer( 3, GL_FLOAT, 3*sizeof(float), cube_vertices );
        glEnableClientState( GL_TEXTURE_COORD_ARRAY );
        glTexCoordPointer( 2, GL_FLOAT, 2*sizeof(float), cube_texcoords );
        glDrawElements( GL_TRIANGLES, 
                sizeof(cube_indices)/sizeof(cube_indices[0]), GL_UNSIGNED_SHORT, cube_indices );
        glDisableClientState( GL_TEXTURE_COORD_ARRAY );

        glPopMatrix();
        glDisable( GL_TEXTURE_2D );

        glVertexPointer( 3, GL_FLOAT, 3*sizeof(float), bottom_occludder );
        glDrawElements( GL_TRIANGLES, 
                sizeof(bottom_indices)/sizeof(bottom_indices[0]), GL_UNSIGNED_SHORT, bottom_indices );

        glDisableClientState( GL_VERTEX_ARRAY );

        glutSwapBuffers();
}

int main( int argc, char * argv[] )
{
        glutInit( &argc, argv );
        glutInitDisplayMode( GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB );
        glutCreateWindow( "faogenlib example" );
        glutReshapeWindow( 800, 600 );
        glutReshapeFunc( reshape );
        glutKeyboardFunc( key );
        
        build_plane();
        if( !generate_example() )
                return 1;

        glClearColor( 0.5f, 0.5f, 0.6f, 1.f );
        glMatrixMode( GL_MODELVIEW );

        glEnable( GL_CULL_FACE );
        glEnable( GL_DEPTH_TEST );

        glutIdleFunc(idle);
        glutDisplayFunc(display);
        glutMainLoop(); 

        return 0;
}

---