VertexCompute Class Reference

Inheritance diagram for VertexCompute:

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

Protected Attributes
Mesh	m_mesh
Orbiter	m_camera
GLuint	m_vao
GLuint	m_buffer
GLuint	m_transformed_buffer
GLuint	m_program
GLuint	m_compute_program
int	m_compute_threads
int	m_compute_groups
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 68 of file tuto_vertex_compute.cpp.

Member Function Documentation

init()

int VertexCompute::init ( )

inlinevirtual

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

Implements App.

Definition at line 74 of file tuto_vertex_compute.cpp.

    {
        m_mesh= read_mesh("data/bigguy.obj");
        printf("  positions %d\n", m_mesh.vertex_count());
        printf("  triangles %d\n", m_mesh.triangle_count());
        
        // construit le storage buffer contenant les positions, les normales et les texcoords, en utilisant les types alignes
        struct vertex
        {
            glsl::vec3 position;
        };
        
        // recupere les attributs du mesh
        std::vector<vertex> data(m_mesh.vertex_count());
        for(int i= 0; i < m_mesh.vertex_count(); i++)
            data[i].position= m_mesh.positions().at(i);
        
        // vao par defaut, pas d'attribut. les positions des sommets sont dans le storage buffer...
        glGenVertexArrays(1, &m_vao);
        glBindVertexArray(m_vao);
        
        // storage buffers
        glGenBuffers(1, &m_buffer);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_buffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vertex) * data.size(), data.data(), GL_STREAM_READ);
        
        glGenBuffers(1, &m_transformed_buffer);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_transformed_buffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec4) * data.size(), std::vector<vec4>(data.size(), vec4()).data(), GL_STREAM_COPY);
        
        // 
        m_program= read_program("tutos/pipeline_compute.glsl");
        program_print_errors(m_program);
        
        // compute shader
        m_compute_program= read_program("tutos/vertex_compute.glsl");
        program_print_errors(m_compute_program);
        
        // recupere le nombre de threads de chaque groupe du compute shader
        GLint threads[3]= { };
        glGetProgramiv(m_compute_program, GL_COMPUTE_WORK_GROUP_SIZE, threads);
        printf("threads / group x %d, y %d, z %d\n", threads[0], threads[1], threads[2]);
        m_compute_threads= threads[0];
        
        // nombre de groupes de threads a executer pour transformer les sommets du mesh
        m_compute_groups= m_mesh.vertex_count() / m_compute_threads;
        if(m_mesh.vertex_count() % m_compute_threads)
            m_compute_groups= m_compute_groups +1;
        
        printf("groups %d= %d threads\n", m_compute_groups, m_compute_groups*m_compute_threads);
        
        //
        Point pmin, pmax;
        m_mesh.bounds(pmin, pmax);
        m_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
        
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);      // ne dessine que les aretes des triangles
        glLineWidth(2);
        
        return 0;   // ras, pas d'erreur
    }

quit()

int VertexCompute::quit ( )

inlinevirtual

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

Implements App.

Definition at line 144 of file tuto_vertex_compute.cpp.

    {
        m_mesh.release();
        release_program(m_program);
        release_program(m_compute_program);
        glDeleteBuffers(1, &m_buffer);
        glDeleteBuffers(1, &m_transformed_buffer);
        glDeleteVertexArrays(1, &m_vao);
        return 0;
    }

render()

int VertexCompute::render ( )

inlinevirtual

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

Implements App.

Definition at line 156 of file tuto_vertex_compute.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());
 
        // selectionne les buffers
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_buffer);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_transformed_buffer);
        
        // etape 1 : utilise le compute shader pour transformer les positions des sommets du mesh.
        glUseProgram(m_compute_program);
        
        // uniforms du compute shader
        Transform model= RotationY(global_time() / 60);
        Transform view= m_camera.view();
        Transform projection= m_camera.projection(window_width(), window_height(), 45);
        Transform mvp= projection * view * model;
        
        program_uniform(m_compute_program, "mvpMatrix", mvp);
        
        // go !!
        glDispatchCompute(m_compute_groups, 1, 1);
        
        // etape 2 : synchronisation, attendre les resultats du compute shader
        glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
        
        // etape 3 : utilise les sommets transformes (par le compute shader) pour afficher le mesh.
        glBindVertexArray(m_vao);
        glUseProgram(m_program);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_transformed_buffer);
 
        glDrawArrays(GL_TRIANGLES, 0, m_mesh.vertex_count());
 
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, 0);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, 0);
 
        return 1;
    }

---

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

• tutos/tuto_vertex_compute.cpp