IS Struct Reference

Inheritance diagram for IS:

Public Member Functions
	IS (const char *filename)
int	init ()
	a deriver pour creer 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	quit ()
	a deriver pour detruire les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon. More...
int	build_sources ()
bool	direct (const Ray &ray)
int	build_triangles ()
bool	intersect (const Ray &ray, Hit &hit)
Public Member Functions inherited from App
	App (const int width, const int height, const int major=3, const int minor=3, const int samples=0)
	constructeur, dimensions de la fenetre et version d'openGL. More...
virtual int	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps. More...
int	run ()
	execution de l'application. More...

Protected Attributes
Mesh	m_mesh
Orbiter	m_camera
std::vector< Triangle >	m_triangles
std::vector< Source >	m_sources
Image	m_hitp
Image	m_hitn
Image	m_hitv
GLuint	m_vao
GLuint	m_program
GLuint	m_ptexture
GLuint	m_ntexture
GLuint	m_vtexture
Protected Attributes inherited from App
Window	m_window
Context	m_context
bool	sync

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

Detailed Description

Definition at line 180 of file tuto_is.cpp.

Member Function Documentation

init()

int IS::init ( )

inlinevirtual

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

Implements App.

Definition at line 200 of file tuto_is.cpp.

    {
        if(m_mesh == Mesh::error())
            return -1;
        
        m_ptexture= make_texture(0, window_width(), window_height());
        m_ntexture= make_texture(1, window_width(), window_height());
        m_vtexture= make_texture(2, window_width(), window_height());
        
        m_hitp= Image(window_width(), window_height());
        m_hitn= Image(window_width(), window_height());
        m_hitv= Image(window_width(), window_height());
        
        glGenVertexArrays(1, &m_vao);
        glBindVertexArray(m_vao);
        
        m_program= read_program("tutos/M2/is.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;
    }

render()

int IS::render ( )

inlinevirtual

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

Implements App.

Definition at line 229 of file tuto_is.cpp.

    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        if(key_state('r'))
        {
            clear_key_state('r');
            reload_program(m_program, "tutos/M2/is.glsl");
            program_print_errors(m_program);
        }
        
        if(key_state('f'))
        {
            clear_key_state('f');
            Point pmin, pmax;
            m_mesh.bounds(pmin, pmax);
            m_camera.lookat(pmin, pmax);        
        }
        
        // 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());
        
        m_camera.projection(window_width(), window_height(), 45);
        
        static int mode= 0;
        static vec2 texcoord= vec2(0, 0);
        if(key_state(' '))
        {
            clear_key_state(' ');
            mode= (mode +1) % 2;
        
            if(mode == 1)
            {
                int mx, my;
                SDL_GetMouseState(&mx, &my);
                vec2 pixel= vec2(mx, window_height() - my -1);
                texcoord= vec2(pixel.x / m_hitp.width(), pixel.y / m_hitp.height());
                printf("pixel %f %f\n", pixel.x, pixel.y);
                
                // go
                Point d0;
                Vector dx0, dy0;
                m_camera.frame(0, d0, dx0, dy0);
                
                Point d1;
                Vector dx1, dy1;
                m_camera.frame(1, d1, dx1, dy1);
                
                // pixel
                Point o= d0 + pixel.x*dx0 + pixel.y*dy0;
                Point e= d1 + pixel.x*dx1 + pixel.y*dy1;
 
                Point point;
                Vector normal;
                
                Ray ray(o, e);
                Hit hit;
                if(intersect(ray, hit))
                {
                    point= hit.p;
                    normal= hit.n;
                    
                    // frame
                #pragma omp parallel for schedule(dynamic, 16)
                    for(int y= 0; y < m_hitp.height(); y++)
                    for(int x= 0; x < m_hitp.width(); x++)
                    {
                        // clear
                        m_hitp(x, y)= Black();
                        m_hitn(x, y)= Black();
                        m_hitv(x, y)= Black();
                        
                        Point o= d0 + x*dx0 + y*dy0;
                        Point e= d1 + x*dx1 + y*dy1;
                        
                        Ray ray(o, e);
                        Hit hit;
                        if(intersect(ray, hit))
                        {
                            m_hitp(x, y)= Color(hit.p.x, hit.p.y, hit.p.z);
                            m_hitn(x, y)= Color(hit.n.x, hit.n.y, hit.n.z);
                            
                            Ray shadow(hit.p + hit.n * 0.001f, point + normal * 0.001f);
                            Hit shadow_hit;
                            int v= 1;
                            if(intersect(shadow, shadow_hit))
                                v= 0;
                            
                            m_hitv(x, y)= Color(v, v, v);
                        }
                    }
                    
                    // transferre les donnees
                    glActiveTexture(GL_TEXTURE0);
                    glBindTexture(GL_TEXTURE_2D, m_ptexture);
                    glTexSubImage2D(GL_TEXTURE_2D, 0, 
                        0, 0, m_hitp.width(), m_hitp.height(),
                        GL_RGBA, GL_FLOAT, m_hitp.data());
                    
                    glActiveTexture(GL_TEXTURE0 +1);
                    glBindTexture(GL_TEXTURE_2D, m_ntexture);
                    glTexSubImage2D(GL_TEXTURE_2D, 0, 
                        0, 0, m_hitn.width(), m_hitn.height(),
                        GL_RGBA, GL_FLOAT, m_hitn.data());
                    
                    glActiveTexture(GL_TEXTURE0 +2);
                    glBindTexture(GL_TEXTURE_2D, m_vtexture);
                    glTexSubImage2D(GL_TEXTURE_2D, 0, 
                        0, 0, m_hitv.width(), m_hitv.height(),
                        GL_RGBA, GL_FLOAT, m_hitv.data());
                }
            }
        }
        
        if(mode == 1)
        {
            glBindVertexArray(m_vao);
            glUseProgram(m_program);
            
            program_uniform(m_program, "ptexture", 0);
            program_uniform(m_program, "ntexture", 1);
            program_uniform(m_program, "vtexture", 2);
            program_uniform(m_program, "pixel", texcoord);
            program_uniform(m_program, "mode", mode);
            
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, m_ptexture);
            glActiveTexture(GL_TEXTURE0 +1);
            glBindTexture(GL_TEXTURE_2D, m_ntexture);
            glActiveTexture(GL_TEXTURE0 +2);
            glBindTexture(GL_TEXTURE_2D, m_vtexture);
            
            glDrawArrays(GL_TRIANGLES, 0, 3);
        }
        
        else if(mode == 0)
            draw(m_mesh, m_camera);
        
        //
        if(key_state('s'))
        {
            clear_key_state('s');
            
            static int n= 1;
            char tmp[1024];
            sprintf(tmp, "screenshot%02d.png", n++);
            printf("writing %s...\n", tmp);
            screenshot(tmp);
        }        
        
        return 1;
    }

quit()

int IS::quit ( )

inlinevirtual

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

Implements App.

Definition at line 389 of file tuto_is.cpp.

    {
        m_mesh.release();
        return 0;
    }

---

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

• tutos/M2/tuto_is.cpp