tuto9_materials.cpp

Go to the documentation of this file.

 
#include "mat.h"
#include "mesh.h"
#include "wavefront.h"
 
#include "orbiter.h"
#include "program.h"
#include "uniforms.h"
#include "draw.h"
 
#include "app_camera.h"        // classe Application a deriver
 
 
class TP : public AppCamera
{
public:
    // constructeur : donner les dimensions de l'image, et eventuellement la version d'openGL.
    TP( ) : AppCamera(1024, 640) {}
    
    int init( )
    {
        m_objet= read_mesh("data/robot.obj");
        if(m_objet.materials().count() == 0)
            // pas de matieres, pas d'affichage
            return -1;
        printf("%d materials.\n", m_objet.materials().count());
        
        // etape 1 : creer le shader program
        m_program= read_program("gkit2_tutos/tuto9_materials.glsl");
        program_print_errors(m_program);
        
        // recupere les matieres.
        // le shader declare un tableau de 16 matieres
        m_colors.resize(16);
        
        // copier les matieres utilisees
        const Materials& materials= m_objet.materials();
        assert(materials.count() <= int(m_colors.size()));
        for(int i= 0; i < materials.count(); i++)
        {
            m_colors[i]= materials.material(i).diffuse;
            printf("  colors[%d] %f %f %f\n", i, m_colors[i].r, m_colors[i].g, m_colors[i].b);
        }
        
        // placer la camera
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        camera().lookat(pmin, pmax);
        
        // etat openGL par defaut
        glEnable(GL_FRAMEBUFFER_SRGB);
        
        glClearColor(0.1, 0.1, 0.1, 1);             // couleur par defaut de la fenetre
        
        glClearDepth(1);                            // 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
    }
    
    // destruction des objets de l'application
    int quit( )
    {
        // etape 3 : detruire le shader program
        release_program(m_program);
        m_objet.release();
        return 0;
    }
    
    // dessiner une nouvelle image
    int render( )
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // dessiner m_objet avec le shader program
        // configurer le pipeline 
        glUseProgram(m_program);
        
        // configurer le shader program
        // . recuperer les transformations
        Transform model= RotationY(global_time() / 40);
        // Transform model= RotationY( 35 );
        Transform view= camera().view();
        Transform projection= camera().projection();
        
        // . composer les transformations : model, view et projection
        Transform mv= view * model;
        Transform mvp= projection * mv;
        
        // . parametrer le shader program :
        program_uniform(m_program, "mvpMatrix", mvp);
        program_uniform(m_program, "mvMatrix", mv);
        
        // . parametres "supplementaires" : les couleurs des matieres
        program_uniform(m_program, "materials", m_colors);
        
        // go !
        m_objet.draw(m_program);
        
        return 1;
    }
 
protected:
    Transform m_model;
    Mesh m_objet;
    Orbiter m_camera;
    GLuint m_texture;
    GLuint m_program;
    std::vector<Color> m_colors;
};
 
 
int main( int argc, char **argv )
{
    TP tp;
    tp.run();
    
    return 0;
}