TP Class Reference

Inheritance diagram for TP:

Classes
struct	Object

Public Member Functions
	TP (const int msaa=1)
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...
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...
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...
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...
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	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps. More...
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application. More...
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...
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...
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...
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...
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...
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...
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...
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...
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...
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...
void	init_dynamic_cubemap (const int w, const int h)
int	init ()
	a deriver pour creer les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon. More...
void	scene (std::vector< Object > &objects)
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application. More...
int	quit ()
	a deriver pour detruire les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon. More...
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...
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	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps. More...
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application. More...
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...
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...
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...
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	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps. More...
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application. More...
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	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps. More...
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application. More...
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...
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...
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	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps. More...
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application. More...
Public Member Functions inherited from AppCamera
	AppCamera (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...
const Orbiter &	camera () const
	renvoie l'orbiter gere par l'application. More...
Orbiter &	camera ()
	renvoie l'orbiter gere par 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...
int	run ()
	execution de l'application. More...
Public Member Functions inherited from AppTime
	AppTime (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...

Protected Attributes
Mesh	m_objet
Mesh	m_repere
GLuint	m_vao
GLuint	m_program
std::vector< GLuint >	m_textures
std::vector< TriangleGroup >	m_groups
Mesh	m_grid
Orbiter	m_camera
GLuint	m_texture
Mesh	m_cube
Transform	m_model
Buffers	m_objet
std::vector< Color >	m_colors
GLuint	m_texture0
GLuint	m_texture1
GLuint	m_program_draw
Mesh	m_local
Mesh	m_proxy
Mesh	m_frustum
Mesh	m_ground
Transform	m_position
Mesh	m_frustum_cube
Framebuffer	m_framebuffer
GLuint	m_mesh_program
GLuint	m_decal_program
Mesh	m_object
GLuint	m_program_render
GLuint	m_texture_cubemap
GLuint	m_depth_cubemap
GLuint	m_framebuffer
GLuint	m_shadow_program
Orbiter	m_observer
Point	m_pmin
Point	m_pmax
GLuint	m_indirect_buffer
GLuint	m_model_buffer
GLuint	m_time_query
GLuint	m_program_direct
Text	m_console
std::vector< IndirectParam >	m_multi_indirect
std::vector< Transform >	m_multi_model
GLuint	m_parameter_buffer
GLuint	m_object_buffer
GLuint	m_remap_buffer
GLuint	m_program_cull
std::vector< Object >	m_objects
int	m_draws
GLuint	m_indirect_count_buffer
GLuint	m_vertex_buffer
unsigned int	m_vertex_count
Protected Attributes inherited from AppCamera
Orbiter	m_camera
Protected Attributes inherited from App
Window	m_window
Context	m_context
bool	sync
Protected Attributes inherited from AppTime
std::chrono::high_resolution_clock::time_point	m_cpu_start
std::chrono::high_resolution_clock::time_point	m_cpu_stop
GLuint	m_time_query [MAX_FRAMES]
GLint64	m_frame_time
int	m_frame
Text	m_console

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

Detailed Description

Definition at line 58 of file alpha.cpp.

---

Class Documentation

TP::Object

struct TP::Object

Definition at line 203 of file tuto_dynamic_cubemap.cpp.

Class Members
Transform	model
Color	color

Member Function Documentation

init() [1/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 65 of file alpha.cpp.

    {
        // decrire un repere / grille 
        m_repere= make_grid(20);
        
        Point grid_pmin, grid_pmax;
        m_repere.bounds(grid_pmin, grid_pmax);
        
        //~ m_objet= read_mesh("data/alpha.obj");   // utiliser alpha.glsl !!
        m_objet= read_mesh("data/robot.obj");   // utiliser alpha_notexture.glsl !!
        
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        
        pmin= min(pmin, grid_pmin);
        pmax= max(pmax, grid_pmax);
 
        // parametrer la camera de l'application, renvoyee par la fonction camera()
        camera().lookat(pmin, pmax);
        
        // charge les textures, si necessaire
        Materials& materials= m_objet.materials();
        m_textures.resize(materials.filename_count());
        for(unsigned i= 0; i < m_textures.size(); i++)
            m_textures[i]= read_texture(0, materials.filename(i));
        
        // affiche les matieres
        {
            for(int i= 0; i < materials.count(); i++)
            {
                const Material& material= materials.material(i);
                printf("material[%d] '%s' kd %f %f %f ", i, materials.name(i), material.diffuse.r, material.diffuse.g, material.diffuse.b);
                if(material.diffuse_texture != -1)
                    printf("texture '%s'", materials.filename(material.diffuse_texture));
                printf("\n");
            }
        }
        
        m_groups= m_objet.groups();
        m_vao= m_objet.create_buffers( /* texcoords */ true, /* normals */ true, /* color */ false, /* material index */ false);
        
        //
        //~ m_program= read_program("tutos/alpha.glsl");
        m_program= read_program("tutos/alpha_notexture.glsl");
        program_print_errors(m_program);
        
        // 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
        
        glEnable(GL_MULTISAMPLE);   // MSAA
        glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);  // transformer la transparence en visibilite des samples MSAA
        
        return 0;   // ras, pas d'erreur
    }

quit() [1/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 125 of file alpha.cpp.

    {
        m_objet.release();
        m_repere.release();
        return 0;
    }

render() [1/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 133 of file alpha.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // dessine aussi le repere, pour le meme point de vue
        draw(m_repere, Identity(), camera());
        
        if(key_state('r'))
        {
            // recharge le shader a la volee...
            clear_key_state('r');
            //~ reload_program(m_program, "tutos/alpha.glsl");
            reload_program(m_program, "tutos/alpha_notexture.glsl");
            program_print_errors(m_program);
        }
        
        glBindVertexArray(m_vao);
        glUseProgram(m_program);
        
        Transform model= Identity();
        Transform view= camera().view();
        Transform projection= camera().projection();
        Transform mv= view * model;
        Transform mvp= projection * mv;
        
        program_uniform(m_program, "mvMatrix", mv);
        program_uniform(m_program, "mvpMatrix", mvp);
        
        // dessine tous les groupes de triangles, tries par matiere
        const Materials& materials= m_objet.materials();
        for(unsigned i= 0; i < m_groups.size(); i++)
        {
            const Material& material= materials.material(m_groups[i].material_index);
            if(material.diffuse_texture != -1)
                program_use_texture(m_program, "alpha", 0, m_textures[material.diffuse_texture]);
            else
                program_use_texture(m_program, "alpha", 0, 0);
            
            //~ printf("group[%u] material %d first %d n %d, texture %d\n", i, m_groups[i].material_index, m_groups[i].first, m_groups[i].n, material.diffuse_texture);
            
            glDrawArrays(GL_TRIANGLES, m_groups[i].first, m_groups[i].n);
        }
        
        if(key_state('s'))
        {
            clear_key_state('s');
            static int id= 1;
            screenshot("alpha", id++);
        }
        
        // continuer...
        return 1;
    }

init() [2/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 63 of file tuto10.cpp.

    {
        m_grid= make_grid();
        m_objet= read_mesh("data/cube.obj");
        
        Point pmin, pmax;
        m_grid.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
 
        // etape 1 : creer le shader program
        m_program= read_program("tutos/tuto10.glsl");
        program_print_errors(m_program);
        
        // 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() [2/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 87 of file tuto10.cpp.

    {
        // etape 3 : detruire le shader program
        release_program(m_program);
        // et les objets
        m_grid.release();
        m_objet.release();
        return 0;
    }

render() [2/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 98 of file tuto10.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        // recupere l'etat de la souris
        int mx, my;
        unsigned int mb= SDL_GetRelativeMouseState(&mx, &my);
        
        // deplace la camera
        if(mb & SDL_BUTTON(1))
            m_camera.rotation(mx, my);      // tourne autour de l'objet
        else if(mb & SDL_BUTTON(3))
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height()); // deplace le point de rotation
        else if(mb & SDL_BUTTON(2))
            m_camera.move(mx);           // approche / eloigne l'objet
        
        // recupere l'etat de la molette / touch
        SDL_MouseWheelEvent wheel= wheel_event();
        if(wheel.y != 0)
        {
            clear_wheel_event();
            m_camera.move(8.f * wheel.y);  // approche / eloigne l'objet
        }
        
        // recharge le shader program
        if(key_state('r'))
        {
            clear_key_state('r');        // une seule fois...
            reload_program(m_program, "tutos/tuto10.glsl");
            program_print_errors(m_program);
        }
        
        // 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);
        
        // . parametres "supplementaires" :
        
        // go !
        // mesh associe les donnees positions, texcoords, normals et colors aux attributs declares dans le vertex shader
        m_objet.draw(m_program, /* use position */ true, /* use texcoord */ false, /* use normal */ false, /* use color */ false, /* use material index*/ false);
        // relisez le tuto9 sur l'utilisation des shaders et de mesh
 
        // et pour afficher un autre cube d'une autre couleur ?
 
        // dessine aussi le repere et la grille pour le meme point de vue
        draw(m_grid, Identity(), m_camera);
        
        return 1;
    }

init() [3/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 19 of file tuto7.cpp.

    {
        m_objet= read_mesh("data/cube.obj");
        
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        m_texture= read_texture(0, "data/debug2x2red.png");
        
        // 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() [3/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 40 of file tuto7.cpp.

    {
        m_objet.release();
        glDeleteTextures(1, &m_texture);
        
        return 0;
    }

render() [3/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 49 of file tuto7.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        // 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(3))         // le bouton droit est enfonce
            m_camera.move(mx);
        else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        
        // affiche l'objet pour le point de vue de la camera et avec une texture
        draw(m_objet, m_camera, m_texture);
        
        return 1;
    }

init() [4/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 60 of file tuto7_camera.cpp.

    {
        // decrire un repere / grille 
        m_repere= make_grid(10);
        
        // charge un objet
        m_cube= read_mesh("data/cube.obj");
        
        // un autre objet
        m_objet= Mesh(GL_TRIANGLES);
        {
            // ajouter des triplets de sommet == des triangles dans objet...
        }
        
        // 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;   // pas d'erreur, sinon renvoyer -1
    }

quit() [4/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 85 of file tuto7_camera.cpp.

    {
        m_objet.release();
        m_repere.release();
        return 0;   // pas d'erreur
    }

render() [4/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 93 of file tuto7_camera.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
    // dessine le repere, place au centre du monde, pour le point de vue de la camera 
        draw(m_repere, /* model */ Identity(), camera());
        
    // dessine un cube, lui aussi place au centre du monde
        draw(m_cube, /* model */ Identity(), camera());
        
    // dessine le meme cube, a un autre endroit. 
        // il faut modifier la matrice model, qui sert a ca : placer un objet dans le monde, ailleurs qu'a l'origine.
        // par exemple, pour dessiner un 2ieme cube a la verticale au dessus du premier cube :
        // la transformation est une translation le long du vecteur Y= (0, 1, 0), si on veut placer le cube plus haut, il suffit d'utiliser une valeur > 1
        Transform t= Translation(0, 2, 0);
        draw(m_cube, /* model */ t, camera());
        
    // comment dessiner m_objet ?? 
    
    // et sans le superposer au cube deja dessine ?
        
        // continuer, afficher une nouvelle image
        // tant que la fenetre est ouverte...
        return 1;
    }

init() [5/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 19 of file tuto8.cpp.

    {
        m_objet= read_mesh("data/cube.obj");
        
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
 
        m_texture= read_texture(0, "data/debug2x2red.png");
 
        // 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() [5/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 40 of file tuto8.cpp.

    {
        m_objet.release();
        glDeleteTextures(1, &m_texture);
        
        return 0;
    }

update() [1/5]

int TP::update ( const float  time, const float  delta  )

inlinevirtual

a deriver et redefinir pour animer les objets en fonction du temps.

Reimplemented from App.

Definition at line 48 of file tuto8.cpp.

    {
        // modifier l'orientation du cube a chaque image. 
        // time est le temps ecoule depuis le demarrage de l'application, en millisecondes,
        // delta est le temps ecoule depuis l'affichage de la derniere image / le dernier appel a draw(), en millisecondes.
        
        m_model= RotationY(time / 20);
        return 0;
    }

render() [5/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 59 of file tuto8.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        // 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(3))         // le bouton droit est enfonce
            m_camera.move(mx);
        else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        
        draw(m_objet, m_model, m_camera, m_texture);
        
    /* on pourrait obtenir le meme resultat sans utiliser App::update( ). 
        les parametres time et update sont renvoyes par les fonctions  global_time() et delta_time() :
        draw(m_objet, RotationY(global_time() / 20), m_camera, m_texture);
    */
        
        return 1;
    }

init() [6/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 22 of file tuto9.cpp.

    {
        // charge un obet
        m_objet= read_mesh("data/cube.obj");
        
        // parametre la camera pour observer l'objet
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        camera().lookat(pmin, pmax);
        
        // cree le shader program
        m_program= read_program("tutos/tuto9_color.glsl");
        program_print_errors(m_program);
        
        // 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() [6/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 47 of file tuto9.cpp.

    {
        // detruire le shader program
        release_program(m_program);
        // et l'objet...
        m_objet.release();
        return 0;
    }

render() [6/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 57 of file tuto9.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // configurer le pipeline 
        glUseProgram(m_program);
        
        // configurer le shader program
        // . recuperer les transformations
        Transform model= RotationX(global_time() / 20);         // fait tourner l'objet sur lui meme en fonction du temps
        Transform view= camera().view();
        Transform projection= camera().projection();
        
        // . composer les transformations : model, view et projection
        Transform mvp= projection * view * model;
        
        // . parametrer le shader program :
        //   . transformation : la matrice declaree dans le vertex shader s'appelle 'mvpMatrix'
        program_uniform(m_program, "mvpMatrix", mvp);
        
        // . parametre "supplementaire" :
        //   . couleur des pixels, la couleur declaree dans le fragment shader s'appelle 'color'
        program_uniform(m_program, "color", Color(1, 1, 0, 1));
        
        // go !
        // indiquer quels attributs de sommets du mesh sont necessaires a l'execution du shader.
        // tuto9_color.glsl n'utilise que position. les autres de servent a rien.
        m_objet.draw(m_program, /* use position */ true, /* use texcoord */ false, /* use normal */ false, /* use color */ false, /* use material index*/ false);
        
        return 1;
    }

init() [7/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 65 of file tuto9_buffers.cpp.

    {
        // charger un objet a afficher
        Mesh mesh= read_mesh("data/cube.obj");
        if(!mesh.vertex_count()) return -1;
        
        // etape 1 : creer le vertex buffer et le vao
        m_objet.create(mesh);
        
        // etape 2 : configurer la camera
        Point pmin, pmax;
        mesh.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        // etape 3 : creer le shader program
        m_program= read_program("tutos/tuto9_color.glsl");
        program_print_errors(m_program);
        
        // 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() [7/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 94 of file tuto9_buffers.cpp.

    {
        // etape 4 : detruire le shader program
        release_program(m_program);
        m_objet.release();
        return 0;
    }

render() [7/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 103 of file tuto9_buffers.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // 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(3))         // le bouton droit est enfonce
            m_camera.move(mx);
        else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        
        // etape 2 : dessiner m_objet avec 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 mvp= projection * view * model;
        
        // configurer le shader program
        int location;
        glUseProgram(m_program);
        
        //  . transformation : la matrice declaree dans le vertex shader s'appelle mvpMatrix
        location= glGetUniformLocation(m_program, "mvpMatrix");
        glUniformMatrix4fv(location, 1, GL_TRUE, mvp.data());
        
        // . parametres "supplementaires" :
        // . couleur des pixels, cf la declaration 'uniform vec4 color;' dans le fragment shader
        location= glGetUniformLocation(m_program, "color");
        glUniform4f(location, 1, 1, 0, 1);
        
        // go !
        // selectionner les attributs et les buffers de l'objet
        glBindVertexArray(m_objet.vao);
        
        // dessiner les triangles de l'objet
        glDrawArrays(GL_TRIANGLES, 0, m_objet.vertex_count);
        
        return 1;
    }

init() [8/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 22 of file tuto9_groups.cpp.

    {
        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());
        
        // trie les triangles par matiere et recupere les groupes de triangles utilisant la meme matiere.
        m_groups= m_objet.groups();
        /* remarque : c'est long, donc il vaut mieux le faire une seule fois au debut du programme...
         */
        
        // placer la camera
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        camera().lookat(pmin, pmax);
        
        // creer le shader program, uniquement necessaire pour l'option 2, cf render()
        m_program= read_program("tutos/tuto9_groups.glsl");
        program_print_errors(m_program);
        
        // 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() [8/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 56 of file tuto9_groups.cpp.

    {
        // etape 3 : detruire le shader program
        release_program(m_program);
        m_objet.release();
        return 0;
    }

render() [8/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 65 of file tuto9_groups.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // . recuperer les transformations
        Transform model= RotationY(global_time() / 40);
        Transform view= camera().view();
        Transform projection= camera().projection();
        
    #if 0
        // option 1 : avec les utilitaires draw()
        {
            // dessine chaque groupe de triangle, avec sa matiere
            for(unsigned i= 0; i < m_groups.size(); i++)
                draw(m_groups[i], m_objet, model, view, projection);
                // ou :
                // draw(m_groups[i], m_objet, model, camera());    // meme resultat...
        }
    #else
        // option 2 : dessiner m_objet avec le shader program
        {
            // configurer le pipeline 
            glUseProgram(m_program);
            
            // configurer le shader program
            // . composer les transformations : model, view et projection
            Transform mv= view * model;
            Transform mvp= projection * mv;
            
            // . parametrer le shader program :
            //   . transformations : la matrice declaree dans le vertex shader s'appelle mvpMatrix
            program_uniform(m_program, "mvpMatrix", mvp);
            // et mvMatrix 
            program_uniform(m_program, "mvMatrix", mv);
            
            // afficher chaque groupe
            const Materials& materials= m_objet.materials();
            for(unsigned i= 0; i < m_groups.size(); i++)
            {
                // recuperer la couleur de base de la matiere
                const Material& material= materials(m_groups[i].index);
                
                // . parametres "supplementaires" :
                //   . couleur de la matiere du groupe de triangle
                program_uniform(m_program, "material_color", material.diffuse);
                
                //   . c'est aussi le bon moment pour changer de texture, par exemple...
                // program_use_texture(m_program, "material_texture", ... );
                
                // go !
                // indiquer quels attributs de sommets du mesh sont necessaires a l'execution du shader.
                // tuto9_groups.glsl n'utilise que position et normale. les autres de servent a rien.
                
                // 1 draw par groupe de triangles...
                m_objet.draw(m_groups[i].first, m_groups[i].n, m_program, /* use position */ true, /* use texcoord */ false, /* use normal */ true, /* use color */ false, /* use material index*/ false);
            }
        }
    #endif
        
        /* et directement avec openGL, qu'est ce qui change ?
            
            il faut creer un ou plusieurs buffers pour stocker les positions et les normales de l'objet, et configurer le format de sommet, 
            cf vertex array object / vao, comme dans tuto9_buffers.cpp ou tuto4GL.cpp et tuto4GL_normals.cpp, par exemple
            
            ensuite, c'est comme d'habitude :
            
            glBindVertexAttrib(m_vao);
            glUseProgram(m_program);
            
            // 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);
            
            // dessiner chaque groupe...
            for(unsigned i= 0; i < groups.size(); i++)
            {
                // recuperer la couleur de la matiere du groupe de triangles
                const Material& material= m_objet.materials().material(m_groups[i].material_index);
                Color color= material.diffuse;
                
                // parametrer les uniforms du shader qui dependent de la matiere
                program_uniform(m_program, "material_color", color);
                
                // go ! dessiner les triangles du groupe
                glDrawArrays(GL_TRIANGLES, groups[i].first, groups[i].n);
            }
        */
        
        return 1;
    }

init() [9/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 22 of file tuto9_materials.cpp.

    {
        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("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;
        
        // placer la camera
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        camera().lookat(pmin, pmax);
        
        // 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() [9/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 60 of file tuto9_materials.cpp.

    {
        // etape 3 : detruire le shader program
        release_program(m_program);
        m_objet.release();
        return 0;
    }

render() [9/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 69 of file tuto9_materials.cpp.

    {
        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 view= camera().view();
        Transform projection= 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);
        
        //   . ou, directement en utilisant openGL :
        //   int location= glGetUniformLocation(program, "mvpMatrix");
        //   glUniformMatrix4fv(location, 1, GL_TRUE, mvp.buffer());
        
        // . parametres "supplementaires" :
        //   . couleur diffuse des matieres, cf la declaration 'uniform vec4 materials[];' dans le fragment shader
        int location= glGetUniformLocation(m_program, "materials");
        glUniform4fv(location, m_colors.size(), &m_colors[0].r);
        
        // go !
        // indiquer quels attributs de sommets du mesh sont necessaires a l'execution du shader.
        // tuto9_materials.glsl n'utilise que position et material_index. les autres de servent a rien.
        // 1 draw pour tous les triangles de l'objet.
        m_objet.draw(m_program, /* use position */ true, /* use texcoord */ false, /* use normal */ true, /* use color */ false, /* use material index*/ true);
        
        return 1;
    }

init() [10/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 23 of file tuto9_texture1.cpp.

    {
        m_objet= read_mesh("data/cube.obj");
        
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        m_texture= read_texture(0, "data/debug2x2red.png");
        
        // etape 1 : creer le shader program
        m_program= read_program("tutos/tuto9_texture1.glsl");
        program_print_errors(m_program);
        
        // 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() [10/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 48 of file tuto9_texture1.cpp.

    {
        // etape 3 : detruire le shader program
        release_program(m_program);
        
        m_objet.release();
        glDeleteTextures(1, &m_texture);
        return 0;
    }

render() [10/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 59 of file tuto9_texture1.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // 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(3))         // le bouton droit est enfonce
            m_camera.move(mx);
        else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        
        // 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 mvp= projection * view * model;
        
        // . parametrer le shader program :
        //   . transformation : la matrice declaree dans le vertex shader s'appelle mvpMatrix
        program_uniform(m_program, "mvpMatrix", mvp);
        
        // . parametres "supplementaires" :
        //   . utilisation d'une texture configuree sur l'unite 0, le fragment shader declare "uniform sampler2D texture0;"
        program_use_texture(m_program, "texture0", 0, m_texture);
        
        // go !
        // indiquer quels attributs de sommets du mesh sont necessaires a l'execution du shader.
        // tuto9_texture1.glsl n'utilise que position et texcoord. les autres de servent a rien.
        m_objet.draw(m_program, /* use position */ true, /* use texcoord */ true, /* use normal */ false, /* use color */ false, /* use material index*/ false);
        return 1;
    }

init() [11/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 23 of file tuto9_textures.cpp.

    {
        m_objet= read_mesh("data/cube.obj");
        
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        // lire une texture sur l'unite 0
        m_texture0= read_texture(0, "data/debug2x2red.png");
        // lire une texture sur l'unite 1
        m_texture1= read_texture(1, "data/pacman.png");
        
        // creer le shader program
        m_program= read_program("tutos/tuto9_textures.glsl");
        program_print_errors(m_program);
        
        // 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() [11/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 51 of file tuto9_textures.cpp.

    {
        // etape 3 : detruire le shader program
        release_program(m_program);
        
        m_objet.release();
        glDeleteTextures(1, &m_texture0);
        glDeleteTextures(1, &m_texture1);
        return 0;
    }

render() [11/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 63 of file tuto9_textures.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // 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(3))         // le bouton droit est enfonce
            m_camera.move(mx);
        else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        
        // 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 mvp= projection * view * model;
        
        // . parametrer le shader program :
        //   . transformation : la matrice declaree dans le vertex shader s'appelle mvpMatrix
        program_uniform(m_program, "mvpMatrix", mvp);
        
        // . parametres "supplementaires" :
        //   . utilisation d'une texture configuree sur l'unite 0, le fragment shader declare "uniform sampler2D texture0;"
        program_use_texture(m_program, "texture0", 0, m_texture0);
        
        //   . utilisation d'une texture configuree sur l'unite 1, le fragment shader declare "uniform sampler2D texture1;" 
        program_use_texture(m_program, "texture1", 1, m_texture1);
        
        // go !
        // indiquer quels attributs de sommets du mesh sont necessaires a l'execution du shader.
        // tuto9_textures.glsl n'utilise que position et texcoord. les autres de servent a rien.
        m_objet.draw(m_program, /* use position */ true, /* use texcoord */ true, /* use normal */ false, /* use color */ false, /* use material index*/ false);
        return 1;
    }

init() [12/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 86 of file tuto_cubemap.cpp.

    {
        //~ m_objet= read_mesh("data/cube.obj");
        m_objet= read_mesh("data/bigguy.obj");
        // m_objet= read_mesh("data/ccbigguy.obj");
        
        m_texture= read_cubemap(0, "tutos/cubemap_debug_cross.png");
        // m_texture= read_cubemap(0, "canyon2.jpg");
        
        m_program_draw= read_program("tutos/draw_cubemap.glsl");
        program_print_errors(m_program_draw);
        m_program= read_program("tutos/cubemap.glsl");
        program_print_errors(m_program);
        
        // init camera
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        camera().lookat(pmin, pmax);
        
        // etat openGL par defaut
        glGenVertexArrays(1, &m_vao);
        
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);        // couleur par defaut de la fenetre
        
        glClearDepth(1.f);                          // profondeur par defaut
        glDepthFunc(GL_LEQUAL);                       // ztest, conserver l'intersection la plus proche de la camera
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        
        return 0;   // ras, pas d'erreur
    }

quit() [12/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 118 of file tuto_cubemap.cpp.

    {
        m_objet.release();
        release_program(m_program_draw);
        release_program(m_program);
        glDeleteVertexArrays(1, &m_vao);
        glDeleteTextures(1, &m_texture);
        return 0;
    }

render() [12/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 129 of file tuto_cubemap.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        Transform model= Identity();
        Transform view= camera().view();
        Transform projection= camera().projection();
        Transform viewport= camera().viewport();
        Transform mvp= projection * view * model;
        
        Transform viewInv= Inverse(view);
        Point camera_position= viewInv(Point(0, 0, 0));  // coordonnees de la camera, dans le repere camera... c'est l'origine
        
        // etape 1 : affiche l'objet, utilise la cubemap pour calculer les reflets
        glUseProgram(m_program);
        program_uniform(m_program, "mvpMatrix", mvp);
        program_uniform(m_program, "modelMatrix", model);
        program_uniform(m_program, "camera_position", camera_position);
        
        glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture);
        program_uniform(m_program, "texture0", int(0));
        
        // dessine l'objet, les attributs position et normale sont necessaires a l'execution du shader.
        m_objet.draw(m_program, /* position */ true, /* texcoord */ false, /* normal */ true, /* color */ false, /* material */ false);
        
        // etape 2 : affiche la cube map
        // inverse de la composition des transformations repere monde vers repere image
        Transform inv= Inverse(viewport * projection * view);
        
        glUseProgram(m_program_draw);
        glBindVertexArray(m_vao);
        program_uniform(m_program_draw, "invMatrix", inv);
        program_uniform(m_program_draw, "camera_position", camera_position);
        
        glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture);
        program_uniform(m_program_draw, "texture0", int(0));
        
        glDrawArrays(GL_TRIANGLES, 0, 3);
        
        // nettoyage
        glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
        glUseProgram(0);
        glBindVertexArray(0);
        
        if(key_state('r'))
        {
            clear_key_state('r');
            
            reload_program(m_program_draw, "tutos/draw_cubemap.glsl");
            program_print_errors(m_program_draw);
            reload_program(m_program, "tutos/cubemap.glsl");
            program_print_errors(m_program);
        }
        
        if(key_state('s'))
        {
            clear_key_state('s');
            static int calls= 0;
            screenshot("cubemap_brdf", ++calls);
            printf("screenshot %d\n", calls);
        }
        
        return 1;
    }

init() [13/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 182 of file tuto_decal.cpp.

    {
        // decrire un repere / grille 
        m_repere= make_grid(20);
        m_local= make_grid(2);
        m_ground= make_ground(20);
        //~ m_ground= read_mesh("ground.obj");  // pas dans le depot...
        m_proxy= make_xyz();
        //~ m_proxy= make_camera();
        m_frustum= make_frustum();
        
        // charge l'element
        m_objet= read_mesh("data/robot.obj");
        
        m_texture= read_texture(0, "data/grid.png");
        //~ m_texture= read_texture(0, "orange_splash.png");    // pas dans le depot
        //~ m_texture= read_texture(0, "decal_shadow.png"); // pas dans le depot
        
        // gestion des bordures : 
        // solution 1 : utiliser les parametres openGL pour renvoyer du blanc en dehors de la texture, 
        // soit c'est le shader qui fait le boulot...
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
        float border[]= { 1, 1, 1, 1 };
        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border);
        
        m_program= read_program("tutos/decal.glsl");
        program_print_errors(m_program);
        
        // position initiale de l'objet
        m_position= Identity();
        
        // si l'objet est "gros", il faut regler la camera pour l'observer entierement :
        // recuperer les points extremes de l'objet (son englobant)
        Point pmin, pmax;
        m_ground.bounds(pmin, pmax);
        // parametrer la camera de l'application, renvoyee par la fonction camera()
        camera().lookat(pmin, pmax);
        
        // 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() [13/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 232 of file tuto_decal.cpp.

    {
        m_objet.release();
        m_repere.release();
        m_local.release();
        m_ground.release();
        m_proxy.release();
        
        release_program(m_program);
        glDeleteTextures(1, &m_texture);
        return 0;
    }

render() [13/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 246 of file tuto_decal.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // modifie la position de l'objet en fonction des fleches de direction
        if(key_state(SDLK_UP))
            m_position= m_position * Translation(0, 0, 0.15);     // en avant
        if(key_state(SDLK_DOWN))
            m_position= m_position * Translation(0, 0, -0.15);      // en arriere
        if(key_state(SDLK_PAGEUP))
            m_position= m_position * Translation(0, 0.15, 0);     // en haut
        if(key_state(SDLK_PAGEDOWN))
            m_position= m_position * Translation(0, -0.15, 0);      // en bas
            
        if(key_state(SDLK_LEFT))
            m_position= m_position * RotationY(2);     // tourne vers la droite
        if(key_state(SDLK_RIGHT))
            m_position= m_position * RotationY(-2);     // tourne vers la gauche
        
      
    // dessine le meme objet a un autre endroit. il faut modifier la matrice model, qui sert a ca : placer un objet dans le monde, ailleurs qu'a l'origine.
        // par exemple, a la verticale au dessus du premier cube :
        // la transformation est une translation le long du vecteur Y= (0, 1, 0), si on veut placer le cube plus haut, il suffit d'utiliser une valeur > 1
        
        Transform r= RotationX(-90);
        Transform t= Translation(0,0, 8);
        Transform m= r * t;
        
        Transform decal_view= Inverse(m_position * m);
        //~ Transform decal_projection= Perspective(35, 1, float(0.1), float(10));
        Transform decal_projection= Ortho(-2, 2, -2, 2, float(0.1), float(10));
        
        // transformations de la camera de l'application
        Transform view= camera().view();
        Transform projection= camera().projection();
        
        if(key_state('d'))
        {
            // change de point de vue
            view= decal_view;
            projection= decal_projection;
        }
        
        draw(m_objet, /* model */ m_position, view, projection);
        // dessine aussi le repere local
        draw(m_local, /* model */ m_position, view, projection);
        
    // dessine le 2ieme objet par rapport au premier objet... 
    // compose leurs 2 transformations, les coordonnees du 2ieme objet sont connues dans le repere local du premier objet
        
        // dessine le repere utilise pour placer le decal...
        draw(m_proxy, /* model */ m_position * m, view, projection);
        
        // dessine aussi le frustum 
        if(key_state('f'))
        {
            // passage repere projection vers global : inverse de projection*view
            Transform decal_m= Inverse(decal_projection * decal_view);
            
            draw(m_frustum, decal_m, view, projection);
        }
        
        
        if(key_state(' '))
        {
            // dessine le repere global, pour le meme point de vue
            draw(m_ground, Identity(), view, projection);
            // affichage standard, sans texture projective...
        }
        else
        {
            // affichage du sol avec le decal / texture projective
            glUseProgram(m_program);
            
            // transformations standards
            Transform model;
            Transform mv= view * model;
            Transform mvp= projection * mv;
            
            program_uniform(m_program, "mvpMatrix", mvp);
            program_uniform(m_program, "mvMatrix", mv);
            
            // transformations pour le decal
            // transformation supplementaire pour lire la texture : 
            // passage repere projectif vers repere [0 1]x[0 1]
            Transform decal_viewport= Viewport(1, 1);   
            Transform decal= decal_viewport * decal_projection * decal_view;
            
            program_uniform(m_program, "decalMatrix", decal);
            program_use_texture(m_program, "texture", 0, m_texture);
            
            m_ground.draw(m_program, /* use position */ true, /* use texcoord */ false, /* use normal */ true, /* use color */ false, /* use material index*/ false);
        }
        
        
        // screenshot
        if(key_state('s'))
        {
            clear_key_state('s');
            static int id= 1;
            screenshot("camera", id++);
        }
        
        // continuer...
        return 1;
    }

init() [14/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 138 of file tuto_deferred_decal.cpp.

    {
        // decrire un repere / grille 
        m_repere= make_grid(20);
        m_local= make_grid(2);
        //~ m_ground= make_ground(20);
        m_ground= read_mesh("ground.obj");
        m_proxy= make_xyz();
        m_frustum= make_frustum();
        m_frustum_cube= read_mesh("data/frustum.obj");
        
        // charge l'element
        m_objet= read_mesh("data/robot.obj");
        
        //~ m_texture= read_texture(0, "data/grid.png");
        //~ m_texture= read_texture(0, "decal_shadow.png");
        m_texture= read_texture(0, "orange_splash.png");
        //~ m_texture= read_texture(0, "yellow_splash.png");
        //~ m_texture= read_texture(0, "red_splash.png");
        
        m_mesh_program= read_program("tutos/deferred_mesh.glsl");
        program_print_errors(m_mesh_program);
        m_decal_program= read_program("tutos/deferred_decal.glsl");
        program_print_errors(m_decal_program);
        
        // position initiale de l'objet
        m_position= Identity();
        
        // si l'objet est "gros", il faut regler la camera pour l'observer entierement :
        // recuperer les points extremes de l'objet (son englobant)
        Point pmin, pmax;
        m_ground.bounds(pmin, pmax);
        // parametrer la camera de l'application, renvoyee par la fonction camera()
        camera().lookat(pmin, pmax);
        
        m_framebuffer.create(window_width(), window_height());
        m_framebuffer.clear_color(Black());
        m_framebuffer.clear_depth(1);
        
        // 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_LEQUAL);                       // ztest, conserver l'intersection la plus proche de la camera
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        
        return 0;   // ras, pas d'erreur
    }

quit() [14/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 188 of file tuto_deferred_decal.cpp.

    {
        m_objet.release();
        m_repere.release();
        m_local.release();
        m_ground.release();
        m_proxy.release();
        
        m_framebuffer.release();
        release_program(m_mesh_program);
        release_program(m_decal_program);
        glDeleteTextures(1, &m_texture);
        return 0;
    }

render() [14/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 204 of file tuto_deferred_decal.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // modifie la position de l'objet en fonction des fleches de direction
        if(key_state(SDLK_UP))
            m_position= m_position * Translation(0, 0, 0.15);     // en avant
        if(key_state(SDLK_DOWN))
            m_position= m_position * Translation(0, 0, -0.15);      // en arriere
        if(key_state(SDLK_PAGEUP))
            m_position= m_position * Translation(0, 0.15, 0);     // en haut
        if(key_state(SDLK_PAGEDOWN))
            m_position= m_position * Translation(0, -0.15, 0);      // en bas
            
        if(key_state(SDLK_LEFT))
            m_position= m_position * RotationY(2);     // tourne vers la droite
        if(key_state(SDLK_RIGHT))
            m_position= m_position * RotationY(-2);     // tourne vers la gauche
        
        
        // transformations de la camera de l'application
        Transform view= camera().view();
        Transform projection= camera().projection();
        
    // dessine les objets dans le framebuffer... ceux sur lesquels on veut projetter le decal... 
        {
            m_framebuffer.bind(0, /* store_color */ true, /* store_depth */ true, /* store_position */ false, /* store_texcoord */ false, /* store_normal */ false, /* store_material */ false);
            // dessine le decor
            draw(m_ground, /* model */ Identity(), view, projection);
            
            //~ // dessine l'objet, ou pas ...
            //~ draw(m_objet, /* model */ m_position, view, projection);
            
            m_framebuffer.unbind(window_width(), window_height());
        }
        
    // copie les textures vers la fenetre
        m_framebuffer.blit_color(0, 0, window_width(), window_height());
        m_framebuffer.blit_depth(0, 0, window_width(), window_height());
        
    // positionne le decal
        Transform r= RotationX(-90);
        Transform t= Translation(0,0, 8);
        Transform m= r * t;
        
        Transform decal_view= Inverse(m_position * m);
        //~ Transform decal_projection= Perspective(35, 1, float(0.1), float(10));
        Transform decal_projection= Ortho(-2, 2, -2, 2, float(0.1), float(10));
        
        // dessine le frustum pour verifier que le placement est correct...
        {
            // passage repere projection vers global : inverse de projection*view
            Transform decal_model= Inverse(decal_projection * decal_view);
            
            // juste les aretes 
            draw(m_frustum, decal_model, view, projection);
            //~ // ou le proxy / un cube 
            //~ draw(m_frustum_cube, decal_model, view, projection);
        
            // dessine le repere utilise pour placer le decal...
            draw(m_proxy, /* model */ m_position * m, view, projection);
        }
        
    // dessine / projette le decal sur les objets dessines dans le framebuffer et modifie la couleur des pixels de la fenetre.
    // == execute le fragment shader pour les pixels sur lesquels le decal peut se projetter
        glUseProgram(m_decal_program);
        {
            // passage repere projection vers global : inverse de projection*view
            {
                Transform model= Inverse(decal_projection * decal_view);
                Transform mv= view * model;
                Transform mvp= projection * mv;
                
                program_uniform(m_decal_program, "mvpMatrix", mvp);
            }
            
            {
                // reprojette le fragment stocke dans le framebuffer dans le repere du monde
                Transform viewport= Viewport(window_width(), window_height());
                Transform m= Inverse(viewport * projection * view);
                // puis passage du monde dans le repere de projection du decal
                Transform decal_viewport= Viewport(1, 1);
                Transform inv= decal_viewport * decal_projection * decal_view * m;
                
                program_uniform(m_decal_program, "invMatrix", inv);
            }
            
            program_use_texture(m_decal_program, "decal_texture", 0, m_texture);
            m_framebuffer.use_color_texture(m_decal_program, "color_texture", 1);
            m_framebuffer.use_depth_texture(m_decal_program, "depth_texture", 2);
            
            // dessiner sans modifier le zbuffer / la profondeur stockee
            glDepthMask(GL_FALSE);
            m_frustum_cube.draw(m_decal_program, /* position */ true, /* texcoord */ false, /* normal */ false, /* color */ false, /* material id */ false);
            
            glDepthMask(GL_TRUE);
        }
        
    // dessine les objets, sans decals...
        // dessine l'objet, ou pas ...
        draw(m_objet, /* model */ m_position, view, projection);
        
        // dessine aussi le repere local
        draw(m_local, /* model */ m_position, view, projection);
        
        // screenshot
        if(key_state('s'))
        {
            clear_key_state('s');
            static int id= 1;
            screenshot("camera", id++);
        }
        
        // continuer...
        return 1;
    }

init() [15/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 84 of file tuto_draw_cubemap.cpp.

    {
        m_objet= read_mesh("data/cube.obj");
        m_texture= read_cubemap(0, "tutos/cubemap_debug_cross.png");
        m_program= read_program("tutos/draw_cubemap.glsl");
        program_print_errors(m_program);
        
        // init camera
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        camera().lookat(pmin, pmax);
        
        // etat openGL par defaut
        glGenVertexArrays(1, &m_vao);
        
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);        // couleur par defaut de la fenetre
        
        glClearDepth(1.f);                          // profondeur par defaut
        glDepthFunc(GL_LEQUAL);                     // ztest, conserver l'intersection la plus proche de la camera
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        
        return 0;   // ras, pas d'erreur
    }

quit() [15/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 109 of file tuto_draw_cubemap.cpp.

    {
        m_objet.release();
        release_program(m_program);
        glDeleteVertexArrays(1, &m_vao);
        glDeleteTextures(1, &m_texture);
        return 0;
    }

render() [15/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 119 of file tuto_draw_cubemap.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        glUseProgram(m_program);
        glBindVertexArray(m_vao);
        
        Transform view= camera().view();
        Transform projection= camera().projection();
        Transform viewport= camera().viewport();
        // inverse de la composition des transformations repere monde vers repere image
        Transform inv= Inverse(viewport * projection * view);
        
        Transform viewInv= Inverse(view);
        Point camera_position= viewInv(Point(0, 0, 0));  // coordonnees de la camera, dans le repere camera... c'est l'origine
        
        program_uniform(m_program, "invMatrix", inv);
        program_uniform(m_program, "camera_position", camera_position);
        
        glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture);
        program_uniform(m_program, "texture0", int(0));
        
        glDrawArrays(GL_TRIANGLES, 0, 3);
        
        draw(m_objet, Identity(), view, projection);
        
        // nettoyage
        glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
        glUseProgram(0);
        glBindVertexArray(0);        
        return 1;
    }

init() [16/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 168 of file tuto_dynamic_cubemap.cpp.

    {
        m_object= read_mesh("data/bigguy.obj");
        m_cube= read_mesh("data/cube.obj");
        m_ground= make_grid(20);
        
        m_program_render= read_program("tutos/render_cubemap.glsl");
        program_print_errors(m_program_render);
        m_program_draw= read_program("tutos/draw_cubemap.glsl");
        program_print_errors(m_program_draw);
        m_program= read_program("tutos/cubemap.glsl");
        program_print_errors(m_program);
        
        // init camera
        Point pmin, pmax;
        m_object.bounds(pmin, pmax);
        camera().lookat(pmin*2, pmax*2);
        
        // cubemap dynamique / framebuffer
        init_dynamic_cubemap(1024, 1024);
        
        // etat openGL par defaut
        glGenVertexArrays(1, &m_vao);               // un vao sans attributs, pour dessiner la cubemap
        
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);        // couleur par defaut de la fenetre
        
        glClearDepth(1.f);                          // profondeur par defaut
        glDepthFunc(GL_LEQUAL);                     // !! ztest, conserver l'intersection la plus proche de la camera !!
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        glLineWidth(1.5);
        
        return 0;   // ras, pas d'erreur
    }

render() [16/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 227 of file tuto_dynamic_cubemap.cpp.

    {
        Transform view= camera().view();
        Transform projection= camera().projection();
        Transform viewport= camera().viewport();
        Transform mvp= projection * view;
        
        // "animer" les cubes du "decor"... 
        std::vector<Object> objects;
        scene(objects);
        
        // partie 1 : dessiner le decor dans la cubemap dynamique
        {
            // ... dans le framebuffer
            glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
            glViewport(0, 0, 1024, 1024);       // dimension des faces de la cubemap
            
            // efface les 6 faces couleur + profondeur attachees au framebuffer
            float black[4]= { 0.6, 0.6, 0.6, 1 };
            glClearBufferfv(GL_COLOR, 0, black);
            
            float one= 1;
            glClearBufferfv(GL_DEPTH, 0, &one);
        
            // prepare les 6 matrices view, une par face de la cubemap
            // !! attention a la direction 'up' de lookat... rappel : orientation des textures des cubemaps !!
            Transform faces[6];
            faces[0]= Lookat(/* from */ Point(0, 0, 0), /* to */ Point(1, 0, 0),  /* up */ Vector(0, -1, 0));   // +X
            faces[1]= Lookat(/* from */ Point(0, 0, 0), /* to */ Point(-1, 0, 0), /* up */ Vector(0, -1, 0));   // -X
            
            faces[2]= Lookat(/* from */ Point(0, 0, 0), /* to */ Point(0, 1, 0),  /* up */ Vector(0, 0, 1));    // +Y
            faces[3]= Lookat(/* from */ Point(0, 0, 0), /* to */ Point(0, -1, 0), /* up */ Vector(0, 0, -1));   // -Y
            
            faces[4]= Lookat(/* from */ Point(0, 0, 0), /* to */ Point(0, 0, 1),  /* up */ Vector(0, -1, 0));   // +Z
            faces[5]= Lookat(/* from */ Point(0, 0, 0), /* to */ Point(0, 0, -1), /* up */ Vector(0, -1, 0));   // -Z
            
            // dessine chaque objet du decor
            GLuint vao= m_cube.create_buffers( /* texcoord */ false, /* normal */ true, /* color */ false, /* material */ false);
            glBindVertexArray(vao);
            
            glUseProgram(m_program_render);
            int location_mvp= glGetUniformLocation(m_program_render, "mvpMatrix");
            int location_model= glGetUniformLocation(m_program_render, "modelMatrix");
            
            for(int i= 0; i < int(objects.size()); i++)
            {
                Transform model= objects[i].model;
                Transform projection= Perspective(45, 1, 0.01, 100);
                
                // recalcule les 6 transformations, model est different pour chaque objet 
                Transform mvp[6];
                for(int i= 0; i < 6; i++)
                    mvp[i]= projection * faces[i] * model;
                
                // go !!
                glUniformMatrix4fv(location_mvp, 6, GL_TRUE, mvp[0].data());
                glUniformMatrix4fv(location_model, 1, GL_TRUE, model.data());
                glDrawArraysInstanced(GL_TRIANGLES, 0, m_object.vertex_count(), 6);
            }
            
            // mise a jour des mipmaps des faces de la cubemap
            glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture_cubemap);
            glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
        }
        
        // partie 2 : dessiner avec la cubemap dynamique...
        {
            // ... dans le framebuffer de la fenetre de l'application
            glBindFramebuffer(GL_FRAMEBUFFER, 0);
            glViewport(0, 0, window_width(), window_height());
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            
            Transform viewInv= Inverse(view);
            Point camera_position= viewInv(Point(0, 0, 0));  // coordonnees de la camera, dans le repere camera... c'est l'origine
            
            // affiche l'objet principal, utilise la cubemap pour calculer les reflets
            Transform model= Identity();
            
            glUseProgram(m_program);
            program_uniform(m_program, "mvpMatrix", mvp * model);
            program_uniform(m_program, "modelMatrix", model);
            program_uniform(m_program, "camera_position", camera_position);
            
            glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture_cubemap);
            program_uniform(m_program, "texture0", int(0));
            
            // dessine l'objet, les attributs position et normale sont necessaires a l'execution du shader.
            m_object.draw(m_program, /* position */ true, /* texcoord */ false, /* normal */ true, /* color */ false, /* material */ false );
            
            // et le reste
            draw(m_ground, Identity(), view, projection);
            for(int i= 0; i < int(objects.size()); i++)
                draw(m_cube, objects[i].model, view, projection);
            
            // etape 2 : affiche la cube map 
            // inverse de la transformation repere monde vers repere image
            Transform inv= Inverse(viewport * projection * view);
            
            glUseProgram(m_program_draw);
            glBindVertexArray(m_vao);
            program_uniform(m_program_draw, "invMatrix", inv);
            program_uniform(m_program_draw, "camera_position", camera_position);
            
            glBindTexture(GL_TEXTURE_CUBE_MAP, m_texture_cubemap);
            program_uniform(m_program_draw, "texture0", int(0));
            
            glDrawArrays(GL_TRIANGLES, 0, 3);
        }
        
        // nettoyage
        glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
        glUseProgram(0);
        glBindVertexArray(0);
        
        if(key_state('r'))
        {
            clear_key_state('r');
            
            reload_program(m_program_render, "tutos/render_cubemap.glsl");
            program_print_errors(m_program_render);
            reload_program(m_program_draw, "tutos/draw_cubemap.glsl");
            program_print_errors(m_program_draw);
            reload_program(m_program, "tutos/cubemap.glsl");
            program_print_errors(m_program);
        }
        
        if(key_state('s'))
        {
            clear_key_state('s');
            static int calls= 0;
            screenshot("cubemap_brdf", ++calls);
            printf("screenshot %d\n", calls);
        }
        
        return 1;
    }

quit() [16/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 365 of file tuto_dynamic_cubemap.cpp.

    {
        m_object.release();
        m_cube.release();
        m_ground.release();
        
        release_program(m_program_render);
        release_program(m_program_draw);
        release_program(m_program);
        
        glDeleteVertexArrays(1, &m_vao);
        
        glDeleteTextures(1, &m_texture_cubemap);
        glDeleteTextures(1, &m_depth_cubemap);
        glDeleteFramebuffers(1, &m_framebuffer);
        return 0;
    }

init() [17/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 137 of file tuto_shadows.cpp.

    {
        // decrire un repere / grille 
        m_repere= make_grid(20);
        m_local= make_grid(2);
        m_ground= make_ground(20);
        //~ m_ground= read_mesh("ground.obj");
        m_proxy= make_xyz();
        m_frustum= make_frustum();
        
        // charge l'element
        m_objet= read_mesh("data/robot.obj");
        
        m_decal_program= read_program("tutos/draw_decal.glsl");
        program_print_errors(m_decal_program);
        
        m_shadow_program= read_program("tutos/decal.glsl");
        program_print_errors(m_shadow_program);
        
        // position initiale de l'objet
        m_position= Identity();
        
        // si l'objet est "gros", il faut regler la camera pour l'observer entierement :
        // recuperer les points extremes de l'objet (son englobant)
        Point pmin, pmax;
        m_ground.bounds(pmin, pmax);
        // parametrer la camera de l'application, renvoyee par la fonction camera()
        camera().lookat(pmin, pmax);
        
        // framebuffer pour dessiner les ombres
        m_framebuffer.create(1024, 1024);
        m_framebuffer.clear_color(White());
        m_framebuffer.clear_depth(1);
        
        // 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() [17/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 182 of file tuto_shadows.cpp.

    {
        m_objet.release();
        m_repere.release();
        m_local.release();
        m_ground.release();
        m_proxy.release();
        
        release_program(m_decal_program);
        release_program(m_shadow_program);
        m_framebuffer.release();
        return 0;
    }

render() [17/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 197 of file tuto_shadows.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // modifie la position de l'objet en fonction des fleches de direction
        if(key_state(SDLK_UP))
            m_position= m_position * Translation(0, 0, 0.15);     // en avant
        if(key_state(SDLK_DOWN))
            m_position= m_position * Translation(0, 0, -0.15);      // en arriere
        if(key_state(SDLK_PAGEUP))
            m_position= m_position * Translation(0, 0.15, 0);     // en haut
        if(key_state(SDLK_PAGEDOWN))
            m_position= m_position * Translation(0, -0.15, 0);      // en bas
            
        if(key_state(SDLK_LEFT))
            m_position= m_position * RotationY(2);     // tourne vers la droite
        if(key_state(SDLK_RIGHT))
            m_position= m_position * RotationY(-2);     // tourne vers la gauche
        
        // positionne la projection a la vertice au dessus de l'objet
        Transform r= RotationX(-90);
        Transform t= Translation(0,0, 8);
        Transform m= r * t;
        
        // construit les transformations
        Transform decal_view= Inverse(m_position * m);
        //~ Transform decal_projection= Perspective(40, 1, float(0.1), float(10));  // projection perspective "classique"
        Transform decal_projection= Ortho(-2, 2, -2, 2, float(0.1), float(10));  // projection orthographique
        
        // transformations de la camera de l'application
        Transform view= camera().view();
        Transform projection= camera().projection();
        
        if(key_state('c'))
        {
            // change de point de vue
            view= decal_view;
            projection= decal_projection;
        }
        
        // dessine l'objet
        draw(m_objet, /* model */ m_position, view, projection);
        // dessine aussi le repere local
        draw(m_local, /* model */ m_position, view, projection);
        
        // dessine le repere utilise pour placer le decal...
        draw(m_proxy, /* model */ m_position * m, view, projection);
        
        // dessine aussi le frustum pour projetter le decal
        {
            // passage repere projection vers global : inverse de projection*view
            Transform decal_m= Inverse(decal_projection * decal_view);
            
            draw(m_frustum, decal_m, view, projection);
        }
        
        if(key_state(' '))
        {
            // affichage standard, sans texture projective...
            draw(m_ground, Identity(), view, projection);
        }
        else
        {
        // etape 1: dessine l'objet dans le framebuffer, vu du dessus... utilise les transformations du decal
            m_framebuffer.bind(m_decal_program, /* store_color */ true, /* store_depth */ true, /* store_position */ false, /* store_texcoord */ false, /* store_normal */ false, /* store_material */ false);
            {
                glUseProgram(m_decal_program);
                
                Transform model= m_position;    // position de l'objet
                Transform mv= decal_view * model;
                Transform mvp= decal_projection * mv;
                
                program_uniform(m_decal_program, "mvpMatrix", mvp);
                
                m_objet.draw(m_decal_program,  /* use position */ true, /* use texcoord */ false, /* use normal */ false, /* use color */ false, /* use material index*/ false);
            }
            
        // etape 2: retour a la normale, dessine les autres objets dans la fenetre
            m_framebuffer.unbind(window_width(), window_height());
            
        // etape 3: affichage du sol avec le decal / la texture projective dessinee par l'etape 1
            glUseProgram(m_shadow_program);
            {
                // transformations standards
                Transform model;
                Transform mv= view * model;
                Transform mvp= projection * mv;
                
                program_uniform(m_shadow_program, "mvpMatrix", mvp);
                program_uniform(m_shadow_program, "mvMatrix", mv);
                
                // transformations pour le decal
                // transformation supplementaire pour lire la texture : passage repere projectif vers repere [0 1]x[0 1]
                Transform decal_viewport= Viewport(1, 1);   
                Transform decal= decal_viewport * decal_projection * decal_view;
                
                program_uniform(m_shadow_program, "decalMatrix", decal);
                
                // utilise la texture de l'etape 1 comme decal...
                m_framebuffer.use_color_texture(m_shadow_program, "decal", 0);
                
                // dessiner l'objet avec le decal...
                m_ground.draw(m_shadow_program, /* use position */ true, /* use texcoord */ false, /* use normal */ true, /* use color */ false, /* use material index*/ false);
            }
            
        // etape 4 : nettoyage
            m_framebuffer.unbind_textures();
        }
        
        
        // copie la texture de l'etape 1 / le decal en bas a gauche de la fenetre
        m_framebuffer.blit_color(0, 0, 256, 256);
        
        
        // screenshot
        if(key_state('s'))
        {
            clear_key_state('s');
            static int id= 1;
            screenshot("camera", id++);
        }
        
        // continuer...
        return 1;
    }

init() [18/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 55 of file tuto_transform.cpp.

    {
        // volume visible par une camera, un cube -1 1
        m_frustum= read_mesh("data/frustum.obj");
        
        // grille / plan de reference
        m_grid.create(GL_LINES);
        for(int x= 0; x < 10; x++)
        {
            float px= (float) x - 5.f + 0.5f;
            m_grid.vertex(px, 0, -4.5f); 
            m_grid.vertex(px, 0, 4.5f); 
        }
 
        for(int z= 0; z < 10; z++)
        {
            float pz= (float) z - 5.f + 0.5f;
            m_grid.vertex(-4.5f, 0, pz); 
            m_grid.vertex(4.5f, 0, pz); 
        }
        
        // charge un objet a afficher
        m_objet= read_mesh("data/bigguy.obj");
 
        // conserve (les extremites de) sa boite englobante
        m_objet.bounds(m_pmin, m_pmax);
        m_camera.lookat(m_pmin, m_pmax);
        //~ m_camera.lookat(Point(), 10);
        
        m_objet.default_color(Green());
        
        // 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() [18/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 97 of file tuto_transform.cpp.

    {
        m_frustum.release();
        m_grid.release();
        m_objet.release();
        glDeleteTextures(1, &m_texture);
        
        return 0;
    }

update() [2/5]

int TP::update ( const float  time, const float  delta  )

inlinevirtual

a deriver et redefinir pour animer les objets en fonction du temps.

Reimplemented from App.

Definition at line 107 of file tuto_transform.cpp.

    {
        // modifier l'orientation du cube a chaque image. 
        // time est le temps ecoule depuis le demarrage de l'application, en millisecondes,
        // delta est le temps ecoule depuis l'affichage de la derniere image / le dernier appel a draw(), en millisecondes.
        
        m_model= RotationY(time / 20);
        return 0;
    }

render() [18/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 118 of file tuto_transform.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        // deplace la camera
        int mx, my;
        unsigned int mb= SDL_GetRelativeMouseState(&mx, &my);
        
        if(key_state(' '))
        {
            // deplace la camera "normale"
            if(mb & SDL_BUTTON(1))              // le bouton gauche est enfonce
                m_camera.rotation((float) mx, (float) my);
            else if(mb & SDL_BUTTON(3))         // le bouton droit est enfonce
                m_camera.move((float) mx);
            else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
                m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        }
        else
        {
            // deplace l'observateur
            if(mb & SDL_BUTTON(1))              // le bouton gauche est enfonce
                m_observer.rotation((float) mx / 10, (float) my / 10);
            else if(mb & SDL_BUTTON(3))         // le bouton droit est enfonce
                m_observer.move((float) mx / 10);
            else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
                m_observer.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        }
        
        // affiche l'objet en rouge, si sa boite englobante n'est pas visible pour la camera.
        if(visible(m_camera.projection((float) window_width(), (float)window_height(), 45) * m_camera.view() * m_model, m_pmin, m_pmax))
            m_objet.default_color(Green());
        else
            m_objet.default_color(Red());
        
        
        Transform view= m_observer.view();
        Transform projection= Perspective(45, (float) window_width() / (float) window_height(), .1f, 1000.f);
        
        static bool wireframe= false;
        if(key_state(' '))
        {
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
            
            // afficher le point de vue "normal"
            draw(m_grid, m_camera);
            draw(m_objet, m_model, m_camera);
        }
        else
        {
            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);
            
        #if 1
            // afficher le volume visible de la camera dans le repere monde
            draw(m_grid, Identity(), view, projection);
            draw(m_frustum, Inverse(m_camera.projection((float) window_width(), (float) window_height(), 45) * m_camera.view()), view, projection);
            draw(m_objet, m_model, view, projection);
            
        #else
            // afficher dans le repere image 
            draw(m_grid, m_camera.projection(window_width(), window_height(), 45) * m_camera.view(), view, projection);
            draw(m_frustum, m_camera.projection(window_width(), window_height(), 45) * m_camera.view() * Inverse(m_camera.projection(window_width(), window_height(), 45) * m_camera.view()), view, projection);
            // remarque : ca se simplifie non ??
            draw(m_objet, m_camera.projection(window_width(), window_height(), 45) * m_camera.view() * m_model, view, projection);
        #endif
        }
        
        return 1;
    }

init() [19/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 61 of file tuto_transformations.cpp.

    {
        // decrire un repere / grille 
        m_repere= make_grid(20);
        m_local= make_grid(4);
        
        // charge l'element
        m_objet= read_mesh("data/cube.obj");
        
        // position initiale de l'objet
        m_position= Translation(0, 0.5, 0);
        
        // si l'objet est "gros", il faut regler la camera pour l'observer entierement :
        // recuperer les points extremes de l'objet (son englobant)
        Point pmin, pmax;
        m_repere.bounds(pmin, pmax);
        // parametrer la camera de l'application, renvoyee par la fonction camera()
        camera().lookat(pmin, pmax);
        
        // 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() [19/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 91 of file tuto_transformations.cpp.

    {
        m_objet.release();
        m_repere.release();
        m_local.release();
        return 0;
    }

render() [19/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 100 of file tuto_transformations.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // modifie la position de l'objet en fonction des fleches de direction
        if(key_state(SDLK_UP))
            m_position= m_position * Translation(0, 0, 0.25);     // en avant
        if(key_state(SDLK_DOWN))
            m_position= m_position * Translation(0, 0, -0.25);      // en arriere
            
        if(key_state(SDLK_LEFT))
            m_position= m_position * RotationY(4);     // tourne vers la droite
        if(key_state(SDLK_RIGHT))
            m_position= m_position * RotationY(-4);     // tourne vers la gauche
           
        draw(m_objet, /* model */ m_position, camera());
      
    // dessine le meme objet a un autre endroit. il faut modifier la matrice model, qui sert a ca : placer un objet dans le monde, ailleurs qu'a l'origine.
        // par exemple, a la verticale au dessus du premier cube :
        // la transformation est une translation le long du vecteur Y= (0, 1, 0), si on veut placer le cube plus haut, il suffit d'utiliser une valeur > 1
        Transform t= Translation(0, 2, 0);
        
        // et si on veut le faire tourner en fonction du temps ?
        float time= global_time();
        Transform r= RotationX(time / float(20));
        
        // et pour placer et orienter, les 2 a la fois ? on compose les 2 transformations, et il suffit de multiplier les 2 matrices
        // mais attention : l'ordre de la multiplication des matrices change le resultat...
        //~ // solution 1 : tourner le cube puis le deplacer
        //~ Transform m= t * r;
        
        // solution 2 : deplacer puis tourner le cube
        Transform m= r * t;
        
    // dessine le 2ieme objet par rapport au premier objet... 
    // compose leurs 2 transformations, les coordonnees du 2ieme objet sont connues dans le repere local du premier objet
        draw(m_objet, /* model */ m_position * m, camera());
        
        // dessine aussi le repere local, pour le meme point de vue
        draw(m_local, m_position, camera());
        
        // dessine le repere global, pour le meme point de vue
        draw(m_repere, Identity(), camera());
        
        // screenshot
        if(key_state('s'))
        {
            clear_key_state('s');
            static int id= 1;
            screenshot("camera", id++);
        }
        
        // continuer...
        return 1;
    }

init() [20/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 104 of file tuto_transformations_camera.cpp.

    {
        // decrire un repere / grille 
        m_repere= make_grid(20);
        m_local= make_grid(2);
        m_proxy= make_camera();
        
        // charge l'element
        m_objet= read_mesh("data/cube.obj");
        
        // position initiale de l'objet
        m_position= Identity();
        
        // si l'objet est "gros", il faut regler la camera pour l'observer entierement :
        // recuperer les points extremes de l'objet (son englobant)
        Point pmin, pmax;
        m_repere.bounds(pmin, pmax);
        // parametrer la camera de l'application, renvoyee par la fonction camera()
        camera().lookat(pmin, pmax);
        
        // 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() [20/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 135 of file tuto_transformations_camera.cpp.

    {
        m_objet.release();
        m_repere.release();
        m_local.release();
        m_proxy.release();
        return 0;
    }

render() [20/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 145 of file tuto_transformations_camera.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // modifie la position de l'objet en fonction des fleches de direction
        if(key_state(SDLK_UP))
            m_position= m_position * Translation(0, 0, 0.25);     // en avant
        if(key_state(SDLK_DOWN))
            m_position= m_position * Translation(0, 0, -0.25);      // en arriere
            
        if(key_state(SDLK_LEFT))
            m_position= m_position * RotationY(4);     // tourne vers la droite
        if(key_state(SDLK_RIGHT))
            m_position= m_position * RotationY(-4);     // tourne vers la gauche
        
      
    // dessine le meme objet a un autre endroit. il faut modifier la matrice model, qui sert a ca : placer un objet dans le monde, ailleurs qu'a l'origine.
        // par exemple, a la verticale au dessus du premier cube :
        // la transformation est une translation le long du vecteur Y= (0, 1, 0), si on veut placer le cube plus haut, il suffit d'utiliser une valeur > 1
        Transform t= Translation(0, 2, 0);
        
        float time= global_time();
        static Transform r;
        if(!key_state('f'))
            // rotation en fonction du temps...
            r= RotationX(time / float(20));
        else
        {
            // place la camera derriere le cube
            r= RotationX(15) * RotationY(180);
            t= Translation(1, 1, 4);
        }
        // et pour placer et orienter, les 2 a la fois ? on compose les 2 transformations, et il suffit de multiplier les 2 matrices
        // mais attention : l'ordre de la multiplication des matrices change le resultat...
        Transform m= r * t;
        
        // transformations de la camera de l'application
        Transform view= camera().view();
        Transform projection= camera().projection();
        
        if(key_state(' '))
        {
            view= Inverse(m_position * m);
            projection= Perspective(60, float(window_width()) / float(window_height()), float(0.1), float(40));
        }
        
        draw(m_objet, /* model */ m_position, view, projection);
        
    // dessine le 2ieme objet par rapport au premier objet... 
    // compose leurs 2 transformations, les coordonnees du 2ieme objet sont connues dans le repere local du premier objet
        draw(m_proxy, /* model */ m_position * m, view, projection);
        
        // dessine aussi le repere local, pour le meme point de vue
        draw(m_local, m_position, view, projection);
        
        // dessine le repere global, pour le meme point de vue
        draw(m_repere, Identity(), view, projection);
        
        // screenshot
        if(key_state('s'))
        {
            clear_key_state('s');
            static int id= 1;
            screenshot("camera", id++);
        }
        
        // continuer...
        return 1;
    }

init() [21/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 104 of file tuto_transformations_lookat.cpp.

    {
        // decrire un repere / grille 
        m_repere= make_grid(20);
        m_local= make_grid(2);
        m_proxy= make_camera();
        
        // charge l'element
        m_objet= read_mesh("data/cube.obj");
        
        // position initiale de l'objet
        m_position= Identity();
        
        // si l'objet est "gros", il faut regler la camera pour l'observer entierement :
        // recuperer les points extremes de l'objet (son englobant)
        Point pmin, pmax;
        m_repere.bounds(pmin, pmax);
        // parametrer la camera de l'application, renvoyee par la fonction camera()
        camera().lookat(pmin, pmax);
        
        // 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() [21/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 135 of file tuto_transformations_lookat.cpp.

    {
        m_objet.release();
        m_repere.release();
        m_local.release();
        m_proxy.release();
        return 0;
    }

render() [21/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 145 of file tuto_transformations_lookat.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // modifie la position de l'objet en fonction des fleches de direction
        if(key_state(SDLK_UP))
            m_position= m_position * Translation(0, 0, 0.25);     // en avant
        if(key_state(SDLK_DOWN))
            m_position= m_position * Translation(0, 0, -0.25);      // en arriere
            
        if(key_state(SDLK_LEFT))
            m_position= m_position * RotationY(4);     // tourne vers la droite
        if(key_state(SDLK_RIGHT))
            m_position= m_position * RotationY(-4);     // tourne vers la gauche
        
        // transformations de la camera de l'application
        Transform view= camera().view();
        Transform projection= camera().projection();
        
        // view= Inverse(m_position * m);
        // view= Inverse(m) * Inverse(m_position);
        // et Inverse(m) est le resultat de Lookat()...
        view= Lookat(Point(0,1,-4), Point(0,0,1), Vector(0,1,0)) * Inverse(m_position);
        projection= Perspective(60, float(window_width()) / float(window_height()), float(0.1), float(40));
        Transform m= Inverse(view);
        
        draw(m_objet, /* model */ m_position, view, projection);
        
    // dessine le 2ieme objet par rapport au premier objet... 
    // compose leurs 2 transformations, les coordonnees du 2ieme objet sont connues dans le repere local du premier objet
        draw(m_proxy, /* model */ m, view, projection);
        
        // dessine aussi le repere local, pour le meme point de vue
        draw(m_local, m_position, view, projection);
        
        // dessine le repere global, pour le meme point de vue
        draw(m_repere, Identity(), view, projection);
        
        // screenshot
        if(key_state('s'))
        {
            clear_key_state('s');
            static int id= 1;
            screenshot("lookat", id++);
        }
        
        // continuer...
        return 1;
    }

init() [22/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 36 of file tuto_mdi.cpp.

    {
        //  verifie l'existence des extensions
        if(!GLEW_ARB_shader_draw_parameters)
            return -1;
        printf("GL_ARB_shader_draw_parameters ON\n");
            
        m_objet= read_mesh("data/bigguy.obj");
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        
        m_camera.lookat(pmin - Vector(200, 200,  0), pmax + Vector(200, 200, 0));
        
        // genere les parametres des draws et les transformations
        for(int y= -15; y <= 15; y++)
        for(int x= -15; x <= 15; x++)
        {
            m_multi_model.push_back( Translation(x *20, y *20, 0) );
            m_multi_indirect.push_back( { unsigned(m_objet.vertex_count()), 1, 0, 0} );
        }
        // oui c'est la meme chose qu'un draw instancie, mais c'est juste pour comparer les 2 solutions...
        
        // stockage des parametres du multi draw indirect
        glGenBuffers(1, &m_indirect_buffer);
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(IndirectParam) * m_multi_indirect.size(), &m_multi_indirect.front(), GL_DYNAMIC_DRAW);   
        
        // stockage des matrices des objets
        glGenBuffers(1, &m_model_buffer);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_model_buffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Transform) * m_multi_model.size(), &m_multi_model.front(), GL_DYNAMIC_DRAW);   
        
        // creation des vertex buffer, uniquement les positions
        m_vao= m_objet.create_buffers(/* texcoord */ false, /* normal */ false, /* color */ false, /* material */ false);
        
        // shader programs
        m_program_direct= read_program("tutos/M2/indirect_direct.glsl");        // affichage classique N draws
        program_print_errors(m_program_direct);
        
        m_program= read_program("tutos/M2/indirect.glsl");      // affichage indirect 1 multi draw
        program_print_errors(m_program);
        
        // affichage du temps cpu / gpu
        m_console= create_text();
        
        // mesure du temps gpu de glDraw
        glGenQueries(1, &m_time_query);
        
        // 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() [22/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 94 of file tuto_mdi.cpp.

    {
        glDeleteQueries(1, &m_time_query);
        release_text(m_console);
        
        release_program(m_program);
        m_objet.release();
        glDeleteBuffers(1, &m_indirect_buffer);
        
        return 0;
    }

update() [3/5]

int TP::update ( const float  time, const float  delta  )

inlinevirtual

a deriver et redefinir pour animer les objets en fonction du temps.

Reimplemented from App.

Definition at line 106 of file tuto_mdi.cpp.

    {
        m_model= RotationY(time / 20);
        return 0;
    }

render() [22/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 112 of file tuto_mdi.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // 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(3))         // le bouton droit est enfonce
            m_camera.move(mx);
        else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        
        // mesure le temps d'execution du draw
        glBeginQuery(GL_TIME_ELAPSED, m_time_query);    // pour le gpu
        std::chrono::high_resolution_clock::time_point cpu_start= std::chrono::high_resolution_clock::now();    // pour le cpu
        
    #if 0
        // dessine n copies de l'objet avec 1 glDrawArrays par copie
        glBindVertexArray(m_vao);
        glUseProgram(m_program_direct);
        
        program_uniform(m_program_direct, "modelMatrix", m_model);
        program_uniform(m_program_direct, "vpMatrix", m_camera.projection(window_width(), window_height(), 45) * m_camera.view());
        program_uniform(m_program_direct, "viewMatrix", m_camera.view());
        
        // dessine l'objet avec 1 draw par copie
        for(int i= 0; i < int(m_multi_model.size()); i++)
        {
            program_uniform(m_program_direct, "objectMatrix", m_multi_model[i]);
            glDrawArrays(GL_TRIANGLES, 0, m_objet.vertex_count());
        }
        // dans ce cas particulier, on pourrait utiliser un draw instancie, mais ce n'est pas le but du tuto...
        
    #else
        // dessine n copies de l'objet avec 1 seul appel a glMultiDrawArraysIndirect
        glBindVertexArray(m_vao);
        glUseProgram(m_program);
        
        // uniforms...
        program_uniform(m_program, "modelMatrix", m_model);
        program_uniform(m_program, "vpMatrix", m_camera.projection(window_width(), window_height(), 45) * m_camera.view());
        program_uniform(m_program, "viewMatrix", m_camera.view());
        
        // buffers...
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0,  m_model_buffer);
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        
        glMultiDrawArraysIndirect(m_objet.primitives(), 0, m_multi_indirect.size(), 0);
    #endif
        
        
        // affiche le temps 
        std::chrono::high_resolution_clock::time_point cpu_stop= std::chrono::high_resolution_clock::now();
        long long int cpu_time= std::chrono::duration_cast<std::chrono::nanoseconds>(cpu_stop - cpu_start).count();
        
        glEndQuery(GL_TIME_ELAPSED);
        
        // recupere le resultat de la requete gpu
        GLint64 gpu_time= 0;
        glGetQueryObjecti64v(m_time_query, GL_QUERY_RESULT, &gpu_time);
        
        clear(m_console);
        printf(m_console, 0, 0, "cpu  %02dms %03dus", (int) (cpu_time / 1000000), (int) ((cpu_time / 1000) % 1000));
        printf(m_console, 0, 1, "gpu  %02dms %03dus", (int) (gpu_time / 1000000), (int) ((gpu_time / 1000) % 1000));
        
        draw(m_console, window_width(), window_height());
        
        printf("cpu    %02dms %03dus    ", (int) (cpu_time / 1000000), (int) ((cpu_time / 1000) % 1000));
        printf("gpu    %02dms %03dus\n", (int) (gpu_time / 1000000), (int) ((gpu_time / 1000) % 1000));
        
        return 1;
    }

init() [23/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 44 of file tuto_mdi_count.cpp.

    {
        //  verifie l'existence des extensions
        if(!GLEW_ARB_indirect_parameters) 
            return -1;
        printf("GL_ARB_indirect_parameters ON\n");
        
        if(!GLEW_ARB_shader_draw_parameters)
            return -1;
        printf("GL_ARB_shader_draw_parameters ON\n");
        
        m_object= read_mesh("data/bigguy.obj");
        Point pmin, pmax;
        m_object.bounds(pmin, pmax);
        m_camera.lookat(pmin - Vector(200, 200,  0), pmax + Vector(200, 200, 0));
        
        // genere les parametres des draws et les transformations
        for(int y= -15; y <= 15; y++)
        for(int x= -15; x <= 15; x++)
        {
            m_multi_model.push_back( Translation(x *20, y *20, 0) );
            
            // calcule la bbox de chaque objet dans le repere du monde
            m_objects.push_back( {pmin + Vector(x *20, y *20, 0), unsigned(m_object.vertex_count()), pmax + Vector(x *20, y *20, 0), 0} );
        }
        // oui c'est la meme chose qu'un draw instancie, mais c'est juste pour comparer les 2 solutions...
        
        // transformations des objets
        glGenBuffers(1, &m_model_buffer);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_model_buffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Transform) * m_multi_model.size(), m_multi_model.data(), GL_DYNAMIC_DRAW);
        
        // objets a tester
        glGenBuffers(1, &m_object_buffer);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_object_buffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Object) * m_objects.size(), m_objects.data(), GL_DYNAMIC_DRAW);
        
        // re-indexation des objets visibles
        glGenBuffers(1, &m_remap_buffer);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_remap_buffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int) * m_objects.size(), nullptr, GL_DYNAMIC_DRAW);
        
        // parametres du multi draw indirect
        glGenBuffers(1, &m_indirect_buffer);
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(IndirectParam) * m_objects.size(), nullptr, GL_DYNAMIC_DRAW);   
        
        // nombre de draws de multi draw indirect count 
        glGenBuffers(1, &m_parameter_buffer);
        glBindBuffer(GL_PARAMETER_BUFFER_ARB, m_parameter_buffer);
        glBufferData(GL_PARAMETER_BUFFER_ARB, sizeof(int), nullptr, GL_DYNAMIC_DRAW);
        
        // creation des vertex buffer, uniquement les positions
        m_vao= m_object.create_buffers(/* texcoord */ false, /* normal */ false, /* color */ false, /* material */ false);
        
        // shader program
        m_program_cull= read_program("tutos/M2/indirect_cull.glsl");    // tests de visibilite
        program_print_errors(m_program_cull);
        
        m_program= read_program("tutos/M2/indirect_remap.glsl");        // affichage des objets visibles
        program_print_errors(m_program);
        
        // affichage du temps cpu / gpu
        m_console= create_text();
        
        // mesure du temps gpu de glDraw
        glGenQueries(1, &m_time_query);
        
        // 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() [23/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 122 of file tuto_mdi_count.cpp.

    {
        glDeleteQueries(1, &m_time_query);
        release_text(m_console);
        
        release_program(m_program);
        release_program(m_program_cull);
        
        m_object.release();
        
        glDeleteBuffers(1, &m_indirect_buffer);
        glDeleteBuffers(1, &m_parameter_buffer);
        glDeleteBuffers(1, &m_remap_buffer);
        glDeleteBuffers(1, &m_object_buffer);
        
        return 0;
    }

update() [4/5]

int TP::update ( const float  time, const float  delta  )

inlinevirtual

a deriver et redefinir pour animer les objets en fonction du temps.

Reimplemented from App.

Definition at line 140 of file tuto_mdi_count.cpp.

    {
        m_model= RotationY(time / 20);
        return 0;
    }

render() [23/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 146 of file tuto_mdi_count.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // 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(3))         // le bouton droit est enfonce
            m_camera.move(mx);
        else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        
        // mesure le temps d'execution 
        glBeginQuery(GL_TIME_ELAPSED, m_time_query);    // pour le gpu
        std::chrono::high_resolution_clock::time_point cpu_start= std::chrono::high_resolution_clock::now();    // pour le cpu
        
        // etape 1: compute shader, tester l'inclusion des objets dans une boite
        glUseProgram(m_program_cull);
        
        // uniforms...
        program_uniform(m_program_cull, "bmin", Point(-60, -60, -10));
        program_uniform(m_program_cull, "bmax", Point(60, 60, 10));
        //~ program_uniform(m_program_cull, "bmin", Point(-120, -120, -10));
        //~ program_uniform(m_program_cull, "bmax", Point(120, 120, 10));
        
        // storage buffers...
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_object_buffer);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_remap_buffer);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_indirect_buffer);
        
        // compteur
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_parameter_buffer);
        // remet le compteur a zero
        unsigned int zero= 0;
        glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, &zero);
        // ou
        // glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int), &zero);
        
        // nombre de groupes de shaders
        int n= m_objects.size() / 256;
        if(m_objects.size() % 256)
            n= n +1;
        
        glDispatchCompute(n, 1, 1);
        
        // etape 2 : attendre le resultat
        glMemoryBarrier(GL_COMMAND_BARRIER_BIT | GL_SHADER_STORAGE_BARRIER_BIT);
        
        // etape 3 : afficher les objets visibles (resultat de l'etape 1) avec 1 seul appel a glMultiDrawArraysIndirectCount
        glBindVertexArray(m_vao);
        glUseProgram(m_program);
        
        // uniforms...
        program_uniform(m_program, "modelMatrix", m_model);
        program_uniform(m_program, "vpMatrix", m_camera.projection(window_width(), window_height(), 45) * m_camera.view());
        program_uniform(m_program, "viewMatrix", m_camera.view());
        
        // storage buffers...
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_model_buffer);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_remap_buffer);
        
        // parametres du multi draw...
        glBindBuffer(GL_PARAMETER_BUFFER_ARB, m_parameter_buffer);
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        
        glMultiDrawArraysIndirectCountARB(m_object.primitives(), 0, 0, m_objects.size(), 0);
        
        // affiche le temps 
        glEndQuery(GL_TIME_ELAPSED);
        std::chrono::high_resolution_clock::time_point cpu_stop= std::chrono::high_resolution_clock::now();
        long long int cpu_time= std::chrono::duration_cast<std::chrono::nanoseconds>(cpu_stop - cpu_start).count();
        
        // recupere le resultat de la requete gpu
        GLint64 gpu_time= 0;
        glGetQueryObjecti64v(m_time_query, GL_QUERY_RESULT, &gpu_time);
        
        clear(m_console);
        printf(m_console, 0, 0, "cpu  %02dms %03dus", (int) (cpu_time / 1000000), (int) ((cpu_time / 1000) % 1000));
        printf(m_console, 0, 1, "gpu  %02dms %03dus", (int) (gpu_time / 1000000), (int) ((gpu_time / 1000) % 1000));
        
        draw(m_console, window_width(), window_height());
        
        printf("cpu    %02dms %03dus    ", (int) (cpu_time / 1000000), (int) ((cpu_time / 1000) % 1000));
        printf("gpu    %02dms %03dus\n", (int) (gpu_time / 1000000), (int) ((gpu_time / 1000) % 1000));
        
        return 1;
    }

init() [24/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 29 of file tuto_mdi_elements.cpp.

    {
        // charge un objet indexe
        m_objet= read_indexed_mesh("data/robot.obj");
        
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        // trie les triangles de l'objet par matiere. 
        std::vector<TriangleGroup> groups= m_objet.groups();
        
        /* parcours chaque groupe et construit les parametres du draw correspondant
            on peut afficher les groupes avec glDrawElements, comme d'habitude :
            
            glBindVertexArray(m_vao);
            glUseProgram(m_program);
            glUniform( ... );
            
            for(unsigned i= 0; i < groups.size(); i++)
                glDrawElements(GL_TRIANGLES, /count/ groups[i].n, /type/ GL_UNSIGNED_INT, /offset/ groups[i].first * sizeof(unsigned));
            
            on peut remplir une structure IndirectParam par draw... et utiliser un seul appel a multidrawindirect
        */
        
        std::vector<IndirectParam> params;
        for(unsigned i= 0; i < groups.size(); i++)
        {
            params.push_back({
                unsigned(groups[i].n),      // count
                1,                          // instance_count
                unsigned(groups[i].first),  // first_index
                0,                          // vertex_base, pas la peine de renumeroter les sommets
                0                           // instance_base, pas d'instances
            });
        }
        
        m_draws= params.size();
        
        // transferer dans un buffer
        glGenBuffers(1, &m_indirect_buffer);
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        glBufferData(GL_DRAW_INDIRECT_BUFFER, params.size() * sizeof(IndirectParam), params.data(), GL_STATIC_READ);
        
        // construire aussi les buffers de l'objet
        m_vao= m_objet.create_buffers(/* use texcoord */ false, /* use normal */ true, /* use color */ false, /* use material index */ false);
        
        // et charge un shader..
        m_program= read_program("tutos/M2/indirect_elements.glsl");
        program_print_errors(m_program);
        
        // 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;
    }

quit() [24/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 90 of file tuto_mdi_elements.cpp.

    {
        // todo
        return 0;
    }

render() [24/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 96 of file tuto_mdi_elements.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // recupere les transformations
        Transform model;
        Transform view= camera().view();
        Transform projection= camera().projection();
        Transform mv= view * model;
        Transform mvp= projection * mv;
        
        // parametre le shader
        glBindVertexArray(m_vao);
        glUseProgram(m_program);
        
        program_uniform(m_program, "mvpMatrix", mvp);
        program_uniform(m_program, "mvMatrix", mv);
        
        // parametre du multidraw indirect
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0, m_draws, 0);
        
        return 1;
    }

init() [25/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 29 of file tuto_mdi_elements_count.cpp.

    {
        // verifier la presence de l'extension indirect_parameter, 
        // cf la doc https://registry.khronos.org/OpenGL/extensions/ARB/ARB_indirect_parameters.txt
        if(GLEW_ARB_indirect_parameters == 0)
            // erreur, extension non disponible
            return -1;
            
        // charge un objet indexe
        m_objet= read_indexed_mesh("data/robot.obj");
        
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        // trie les triangles de l'objet par matiere. 
        std::vector<TriangleGroup> groups= m_objet.groups();
        
        /* parcours chaque groupe et construit les parametres du draw correspondant
            on peut afficher les groupes avec glDrawElememnts, comme d'habitude :
            
            glBindVertexArray(m_vao);
            glUseProgram(m_program);
            glUniform();
            
            for(unsigned i= 0; i < groups.size(); i++)
                glDrawElements(GL_TRIANGLES, /count/ groups[i].n, /type/ GL_UNSIGNED_INT, /offset/ groups[i].first * sizeof(unsigned));
            
            on peut remplir une structure IndirectParam par draw... et utiliser un seul appel a multidrawindirect
        */
        
        std::vector<IndirectParam> params;
        for(unsigned i= 0; i < groups.size(); i++)
        {
            params.push_back({
                unsigned(groups[i].n),      // count
                1,                          // instance_count
                unsigned(groups[i].first),  // first_index
                0,                          // vertex_base, pas la peine de renumeroter les sommets
                0                           // instance_base, pas d'instances
            });
        }
        
        m_draws= params.size();
        
        // transferer dans un buffer
        glGenBuffers(1, &m_indirect_buffer);
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        glBufferData(GL_DRAW_INDIRECT_BUFFER, params.size() * sizeof(IndirectParam), params.data(), GL_STATIC_READ);
        
        // buffer pour le nombre de draw
        unsigned n= params.size() - 2;
        glGenBuffers(1, &m_indirect_count_buffer);
        glBindBuffer(GL_PARAMETER_BUFFER_ARB, m_indirect_count_buffer);
        glBufferData(GL_PARAMETER_BUFFER_ARB, sizeof(unsigned), &n, GL_STATIC_READ);
        // remarque : on pourrait aussi ajouter le compteur dans indirect_buffer, mais c'est sans doute plus lisible comme ca...
        
        // construire les buffers de l'objet
        m_vao= m_objet.create_buffers(/* use texcoord */ false, /* use normal */ true, /* use color */ false, /* use material index */ false);
        
        // et charge un shader..
        m_program= read_program("tutos/M2/indirect_elements.glsl");
        program_print_errors(m_program);
        
        // 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;
    }

quit() [25/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 103 of file tuto_mdi_elements_count.cpp.

    {
        // todo
        return 0;
    }

render() [25/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 109 of file tuto_mdi_elements_count.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // recupere les transformations
        Transform model;
        Transform view= camera().view();
        Transform projection= camera().projection();
        Transform mv= view * model;
        Transform mvp= projection * mv;
        
        // parametre le shader
        glBindVertexArray(m_vao);
        glUseProgram(m_program);
        
        program_uniform(m_program, "mvpMatrix", mvp);
        program_uniform(m_program, "mvMatrix", mv);
        
    #if 0
        // parametre du multidraw indirect
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, /* indirect */ 0, /* draw count */ m_draws, /* stride */ 0);
        // on dessine tout
    #else
        
        // parametres du multidraw indirect count 
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_indirect_buffer);
        glBindBuffer(GL_PARAMETER_BUFFER_ARB, m_indirect_count_buffer);
        glMultiDrawElementsIndirectCountARB(GL_TRIANGLES, GL_UNSIGNED_INT, /* indirect */ 0, /* draw count */ 0, /* max draw count */ m_draws, /* stride */ 0);
        // on dessine tout, sauf les 2 derniers groupes... cf init du compteur / indirect_count_buffer
    #endif
        
        return 1;
    }

init() [26/26]

int TP::init ( )

inlinevirtual

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

Implements App.

Definition at line 28 of file tuto_time.cpp.

    {
        // charge un objet et une texture a afficher
        // mode 0 & 1
        m_objet= read_mesh("data/bigguy.obj");        
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        m_camera.lookat(pmin - Vector(20, 20, 0), pmax + Vector(20, 20, 0));
 
        m_texture= read_texture(0, "data/debug2x2red.png");
        
        // mode 2
        // configure le vertex array / format de sommet
        glGenVertexArrays(1, &m_vao);
        glBindVertexArray(m_vao);
        
        // buffer : positions + normals 
        glGenBuffers(1, &m_vertex_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
        glBufferData(GL_ARRAY_BUFFER, m_objet.vertex_buffer_size() + m_objet.normal_buffer_size(), 0, GL_STATIC_DRAW);
        
        // transfere les positions des sommets
        glBufferSubData(GL_ARRAY_BUFFER, /* offset */ 0, /* size */ m_objet.vertex_buffer_size(), /* data */ m_objet.vertex_buffer());
        // configure l'attribut 0, vec3 position
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, /* offset */ 0);
        glEnableVertexAttribArray(0);
        
        // transfere les normales des sommets
        glBufferSubData(GL_ARRAY_BUFFER, /* offset */ m_objet.vertex_buffer_size(), /* size */ m_objet.normal_buffer_size(), /* data */ m_objet.normal_buffer());
        // configure l'attribut 2, vec3 normal
        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, /* offset */ (const GLvoid *) m_objet.vertex_buffer_size());
        glEnableVertexAttribArray(2);
        
        m_vertex_count= m_objet.vertex_count();
 
        m_program= read_program("tutos/M2/instance.glsl");
        program_print_errors(m_program);
        
        // nettoyage 
        glBindVertexArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        
        // mesure du temps gpu de glDraw
        glGenQueries(1, &m_time_query);
 
        // affichage du temps  dans la fenetre
        m_console= create_text();
 
        // 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() [26/26]

int TP::quit ( )

inlinevirtual

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

Implements App.

Definition at line 86 of file tuto_time.cpp.

    {
        glDeleteQueries(1, &m_time_query);
        
        release_text(m_console);
        m_objet.release();
        glDeleteTextures(1, &m_texture);
        
        return 0;
    }

update() [5/5]

int TP::update ( const float  time, const float  delta  )

inlinevirtual

a deriver et redefinir pour animer les objets en fonction du temps.

Reimplemented from App.

Definition at line 97 of file tuto_time.cpp.

    {
        m_model= RotationY(time / 20);
        return 0;
    }

render() [26/26]

int TP::render ( )

inlinevirtual

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

Implements App.

Definition at line 103 of file tuto_time.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        // 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(3))         // le bouton droit est enfonce
            m_camera.move(mx);
        else if(mb & SDL_BUTTON(2))         // le bouton du milieu est enfonce
            m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
        
        // mesure le temps d'execution du draw pour le gpu
        glBeginQuery(GL_TIME_ELAPSED, m_time_query);
        
        // mesure le temps d'execution du draw pour le cpu
        // utilise std::chrono pour mesurer le temps cpu 
        std::chrono::high_resolution_clock::time_point cpu_start= std::chrono::high_resolution_clock::now();
        
        static int mode= 0;
        if(key_state(' '))
        {
            clear_key_state(' ');
            mode= (mode + 1) % 3;
        }
        
        if(mode == 0)
        {
            // dessine 1 objet
            draw(m_objet, m_model, m_camera, m_texture);
        }
        else if(mode == 1)
        {
            // dessine 25 fois l'objet sur une grille
            for(int y= -2; y <= 2; y++)
            for(int x= -2; x <= 2; x++)
            {
                Transform t= Translation(x *20, y *20, 0);
                draw(m_objet, t * m_model, m_camera, m_texture);
            }
        }
        else if(mode == 2)
        {
            // dessine 25 copies de l'objet sur une grille avec un seul glDrawArrayInstanced( ), c'est le vertex shader qui calcule la translation
            // cf gl_InstanceID qui contient l'indice de la copie
            glBindVertexArray(m_vao);
            glUseProgram(m_program);
            
            Transform m= m_model;
            Transform v= m_camera.view();
            Transform p= m_camera.projection(window_width(), window_height(), 45);
            Transform mvp= p * v * m;
            Transform mv= v * m;
            
            program_uniform(m_program, "mvpMatrix", mvp);
            program_uniform(m_program, "normalMatrix", mv.normal());
            
            glDrawArraysInstanced(GL_TRIANGLES, 0, m_vertex_count, 25);
        }
    
        std::chrono::high_resolution_clock::time_point cpu_stop= std::chrono::high_resolution_clock::now();
        // conversion des mesures en duree...
        int cpu_time= std::chrono::duration_cast<std::chrono::microseconds>(cpu_stop - cpu_start).count();
        
        glEndQuery(GL_TIME_ELAPSED);
 
        /* recuperer le resultat de la requete time_elapsed, il faut attendre que le gpu ait fini de dessiner...
            utilise encore std::chrono pour mesurer le temps d'attente.
         */
        std::chrono::high_resolution_clock::time_point wait_start= std::chrono::high_resolution_clock::now();
        
        // attendre le resultat de la requete
        GLint64 gpu_time= 0;
        glGetQueryObjecti64v(m_time_query, GL_QUERY_RESULT, &gpu_time);
 
        std::chrono::high_resolution_clock::time_point wait_stop= std::chrono::high_resolution_clock::now();
        int wait_time= std::chrono::duration_cast<std::chrono::microseconds>(wait_stop - wait_start).count();
 
        // affiche le temps mesure, et formate les valeurs... c'est un peu plus lisible.
        clear(m_console);
        if(mode == 0) printf(m_console, 0, 0, "mode 0 : 1 draw");
        if(mode == 1) printf(m_console, 0, 0, "mode 1 : 25 draws");
        if(mode == 2) printf(m_console, 0, 0, "mode 2 : 1 draw / 25 instances");
        printf(m_console, 0, 1, "cpu  %02dms %03dus", int(cpu_time / 1000), int(cpu_time % 1000));
        printf(m_console, 0, 2, "gpu  %02dms %03dus", int(gpu_time / 1000000), int((gpu_time / 1000) % 1000));
        printf(m_console, 0, 3, "wait %02dms %03dus", int(wait_time / 1000), int(wait_time % 1000));
        
        // affiche le texte dans la fenetre de l'application, utilise console.h
        draw(m_console, window_width(), window_height());
 
        // affiche le temps dans le terminal 
        printf("cpu  %02dms %03dus  ", int(cpu_time / 1000), int(cpu_time % 1000));
        printf("gpu  %02dms %03dus\n", int(gpu_time / 1000000), int((gpu_time / 1000) % 1000));
        
        return 1;
    }

---

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

• tutos/alpha.cpp
• tutos/tuto10.cpp
• tutos/tuto7.cpp
• tutos/tuto7_camera.cpp
• tutos/tuto8.cpp
• tutos/tuto9.cpp
• tutos/tuto9_buffers.cpp
• tutos/tuto9_groups.cpp
• tutos/tuto9_materials.cpp
• tutos/tuto9_texture1.cpp
• tutos/tuto9_textures.cpp
• tutos/tuto_cubemap.cpp
• tutos/tuto_decal.cpp
• tutos/tuto_deferred_decal.cpp
• tutos/tuto_draw_cubemap.cpp
• tutos/tuto_dynamic_cubemap.cpp
• tutos/tuto_shadows.cpp
• tutos/tuto_transform.cpp
• tutos/tuto_transformations.cpp
• tutos/tuto_transformations_camera.cpp
• tutos/tuto_transformations_lookat.cpp
• tutos/M2/tuto_mdi.cpp
• tutos/M2/tuto_mdi_count.cpp
• tutos/M2/tuto_mdi_elements.cpp
• tutos/M2/tuto_mdi_elements_count.cpp
• tutos/M2/tuto_time.cpp