MeshViewer Class Reference

Inheritance diagram for MeshViewer:

Public Member Functions
	MeshViewer (const char *file)
int	init ()
	a deriver pour creer les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon. More...
int	quit ()
	a deriver pour detruire les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon. More...
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application. More...
Public Member Functions inherited from App
	App (const int width, const int height, const int major=3, const int minor=3, const int samples=0)
	constructeur, dimensions de la fenetre et version d'openGL. More...
virtual int	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps. More...
int	run ()
	execution de l'application. More...

Protected Attributes
MeshBuffer	m_mesh
GLuint	m_vao
GLuint	m_vertex_buffer
GLuint	m_index_buffer
int	m_vertex_count
int	m_texcoord_count
int	m_normal_count
int	m_index_count
Transform	m_model
Orbiter	m_camera
GLuint	m_texture
GLuint	m_sampler
GLuint	m_program
Widgets	m_widgets
const char *	m_filename
Protected Attributes inherited from App
Window	m_window
Context	m_context
bool	sync

Additional Inherited Members
Protected Member Functions inherited from App
virtual int	prerender ()
virtual int	postrender ()
void	vsync_off ()

Detailed Description

Definition at line 18 of file mesh_viewer.cpp.

Member Function Documentation

init()

int MeshViewer::init ( )

inlinevirtual

a deriver pour creer les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon.

Implements App.

Definition at line 24 of file mesh_viewer.cpp.

    {
        // lit les donnees
        MeshData data= read_mesh_data(m_filename);
        if(data.positions.size() == 0)
            return -1;
        
        // calcule l'englobant 
        Point pmin, pmax;
        bounds(data, pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        // recalcule les normales des sommets, si necessaire
        if(data.normals.size() == 0)
            normals(data);
        
        // construit les buffers
        m_mesh= buffers(data);
        
        // conserve le nombre de sommets et d'indices
        m_vertex_count= m_mesh.positions.size();
        m_texcoord_count= m_mesh.texcoords.size();
        m_normal_count= m_mesh.normals.size();
        m_index_count= m_mesh.indices.size();
        
        // construit les buffers openGL
        size_t size= m_mesh.vertex_buffer_size() + m_mesh.texcoord_buffer_size() + m_mesh.normal_buffer_size();
        glGenBuffers(1, &m_vertex_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
        glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_STATIC_DRAW);
        
        glGenVertexArrays(1, &m_vao);
        glBindVertexArray(m_vao);
        
        // transfere les positions des sommets
        size_t offset= 0;
        size= m_mesh.vertex_buffer_size();
        glBufferSubData(GL_ARRAY_BUFFER, offset, size, m_mesh.vertex_buffer());
        // et configure l'attribut 0, vec3 position
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset);
        glEnableVertexAttribArray(0);
        
        // transfere les texcoords des sommets
        if(m_mesh.texcoord_buffer_size())
        {
            offset= offset + size;
            size= m_mesh.texcoord_buffer_size();
            glBufferSubData(GL_ARRAY_BUFFER, offset, size, m_mesh.texcoord_buffer());
            // et configure l'attribut 1, vec2 texcoord
            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset);
            glEnableVertexAttribArray(1);
        }
        
        // transfere les normales des sommets
        offset= offset + size;
        size= m_mesh.normal_buffer_size();
        glBufferSubData(GL_ARRAY_BUFFER, offset, size, m_mesh.normal_buffer());
        // et configure l'attribut 2, vec3 normal
        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset);
        glEnableVertexAttribArray(2);
        
        // index buffer
        glGenBuffers(1, &m_index_buffer);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_mesh.index_buffer_size(), m_mesh.index_buffer(), GL_STATIC_DRAW);
        
        // nettoyage
        glBindVertexArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    
        // charge les textures des matieres
        if(m_mesh.texcoord_buffer_size())
        {
            read_textures(m_mesh.materials);
            
            // configure le filtrage des textures de l'unite 0
            //~ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 8.0f);
 
            // configure le filtrage des textures, mode repeat
            glGenSamplers(1, &m_sampler);
            glSamplerParameteri(m_sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
            glSamplerParameteri(m_sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glSamplerParameteri(m_sampler, GL_TEXTURE_WRAP_S, GL_REPEAT);
            glSamplerParameteri(m_sampler, GL_TEXTURE_WRAP_T, GL_REPEAT);
        }
        
        // creer le shader program
        m_program= read_program( smart_path("tutos/mesh_viewer.glsl") );
        program_print_errors(m_program);
        
        // initialise les widgets
        m_widgets= create_widgets();
        
        // etat openGL par defaut
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);        // couleur par defaut de la fenetre
        
        glClearDepth(1.f);                          // profondeur par defaut
        glDepthFunc(GL_LESS);                       // ztest, conserver l'intersection la plus proche de la camera
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        
        return 0;   // ras, pas d'erreur
    }

quit()

int MeshViewer::quit ( )

inlinevirtual

a deriver pour detruire les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon.

Implements App.

Definition at line 129 of file mesh_viewer.cpp.

    {
        release_textures(m_mesh.materials);
        glDeleteBuffers(1, &m_vertex_buffer);
        glDeleteBuffers(1, &m_index_buffer);
        glDeleteVertexArrays(1, &m_vao);
        release_program(m_program);
        
        release_widgets(m_widgets);
        
        return 0;
    }

render()

int MeshViewer::render ( )

inlinevirtual

a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application.

Implements App.

Definition at line 143 of file mesh_viewer.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        static bool wireframe= false;
        if(key_state('w'))
        {
            clear_key_state('w');
            wireframe= !wireframe;
        }
        
        if(!wireframe)
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        else
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        
        // deplace la camera
        int mx, my;
        unsigned int mb= SDL_GetRelativeMouseState(&mx, &my);
        if(mb & SDL_BUTTON(1))              // le bouton gauche est enfonce
            m_camera.rotation(mx, my);
        else if(mb & SDL_BUTTON(2))         // le bouton milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
            //~ m_camera.move(mx);
        else if(mb & SDL_BUTTON(3))         // le bouton droit est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
 
        SDL_MouseWheelEvent wheel= wheel_event();
        if(wheel.y != 0)
        {
            clear_wheel_event();
            m_camera.move(16.f * wheel.y);
        }
 
        
        // etape 2 : dessiner m_objet avec le shader program
        // configurer le pipeline 
        glUseProgram(m_program);
 
        // configurer le shader program
        // . recuperer les transformations
        Transform model; //= RotationX(global_time() / 20);
        Transform view= m_camera.view();
        Transform projection= m_camera.projection(window_width(), window_height(), 45);
        
        // . composer les transformations : model, view et projection
        Transform mv= view * model;
        Transform mvp= projection * mv;
        
        // . parametrer le shader program :
        //   . transformation : la matrice declaree dans le vertex shader s'appelle mvpMatrix
        program_uniform(m_program, "mvpMatrix", mvp);
        program_uniform(m_program, "mvMatrix", mv);
        
        // . parametres "supplementaires" :
        //   . couleur des pixels, cf la declaration 'uniform vec4 color;' dans le fragment shader
        program_uniform(m_program, "diffuse_color", vec4(1, 1, 1, 1));
        
        static bool flat= false;
        if(key_state('f'))
        {
            clear_key_state('f');
            flat= !flat;
        }
 
        static int show= 0;
        static int show_lights= 0;
        static int show_material= 0;
        
        if(key_state(SDLK_RIGHT) || key_state(SDLK_UP))
        {
            clear_key_state(SDLK_RIGHT);
            clear_key_state(SDLK_UP);
            show_material= (show_material +1) %  m_mesh.material_groups.size();
        }
        if(key_state(SDLK_LEFT) || key_state(SDLK_DOWN))
        {
            clear_key_state(SDLK_LEFT);
            clear_key_state(SDLK_DOWN);
            show_material= (show_material +m_mesh.material_groups.size() -1) %  m_mesh.material_groups.size();
        }
        
        // go !
        glBindVertexArray(m_vao);
        for(int i= 0; i < (int) m_mesh.material_groups.size(); i++)
        {
            int material_id= m_mesh.material_groups[i].material;
            const MaterialData& material= m_mesh.materials[material_id];
            
            program_uniform(m_program, "flat_shading", float(flat));
            
            if(show)
                program_uniform(m_program, "diffuse_color", Color((material_id % 100) / 99.f, 1 - (material_id % 10) / 9.f, (material_id % 4) / 3.f));
            else
                program_uniform(m_program, "diffuse_color", material.diffuse);
 
            if(show && material_id == show_material)
                program_uniform(m_program, "diffuse_color", Color(1, 0, 0));
            
            if(show_lights && material.emission.power() > 0)
                program_uniform(m_program, "diffuse_color", Color(.8f, .4f, 0));
            
            program_use_texture(m_program, "diffuse_texture", 0, material.diffuse_texture, m_sampler);
            
            glDrawElements(GL_TRIANGLES, m_mesh.material_groups[i].count, 
                GL_UNSIGNED_INT, m_mesh.index_buffer_offset(m_mesh.material_groups[i].first));
        }
        
        // affiche les infos
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        
        begin(m_widgets);
            label(m_widgets, "mesh '%s', %d vertices %s %s", m_filename, m_vertex_count, 
                m_texcoord_count ? "texcoords" : "", m_normal_count ? "normals" : "");
            
            begin_line(m_widgets);
            label(m_widgets, "%d materials", int(m_mesh.materials.size()));
            
            begin_line(m_widgets);
            button(m_widgets, "show materials", show);
            button(m_widgets, "show lights", show_lights);
        
            if(show)
            {
                const MaterialData& material= m_mesh.materials[show_material];
                
                begin_line(m_widgets);
                label(m_widgets, "material%02d", show_material);
                if(material.specular.power() == 0)
                    label(m_widgets, "diffuse material");
                else if(material.ns > 1)
                    label(m_widgets, "glossy material");
                else
                    label(m_widgets, "undef material ??");
                
                begin_line(m_widgets);
                label(m_widgets, "  Kd %.2f %.2f %.2f", material.diffuse.r, material.diffuse.g, material.diffuse.b);
                begin_line(m_widgets);
                label(m_widgets, "  Ks %.2f %.2f %.2f", material.specular.r, material.specular.g, material.specular.b);
                begin_line(m_widgets);
                label(m_widgets, "  Ns %.2f", material.ns);
                
                begin_line(m_widgets);
                label(m_widgets, "  Kd texture %s", material.diffuse_filename.c_str());
                begin_line(m_widgets);
                label(m_widgets, "  Ns texture %s", material.ns_filename.c_str());
                
            }
            
        end(m_widgets);
        draw(m_widgets, window_width(), window_height());
        
        return 1;
    }

---

The documentation for this class was generated from the following file:

• tutos/mesh_viewer.cpp