DrawInstanceBuffer Class Reference

Inheritance diagram for DrawInstanceBuffer:

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	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...
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
Transform	m_model
Orbiter	m_camera
GLuint	m_vao
GLuint	m_buffer
GLuint	m_instance_buffer
GLuint	m_program
int	m_vertex_count
int	m_instance_count
std::vector< vec3 >	m_positions
GLuint	m_vao_storage
GLuint	m_instance_storage
void *	m_storage
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 App
void	vsync_off ()
Protected Member Functions inherited from AppTime
virtual int	prerender ()
virtual int	postrender ()

Detailed Description

Definition at line 20 of file tuto6GL_buffer.cpp.

Member Function Documentation

init() [1/2]

int DrawInstanceBuffer::init ( )

inlinevirtual

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

Implements App.

Definition at line 26 of file tuto6GL_buffer.cpp.

    {
        // charge un mesh
        Mesh mesh= read_mesh("data/cube.obj");
        if(mesh == Mesh::error()) return -1;
        
        Point pmin, pmax;
        mesh.bounds(pmin, pmax);
        m_camera.lookat(pmin - Vector(40, 40, 40), pmax + Vector(40, 40, 40));
        
        m_vertex_count= mesh.vertex_count();
 
        // cree les buffers et le vao
        glGenVertexArrays(1, &m_vao);
        glBindVertexArray(m_vao);
        
        // buffer : positions + normals
        glGenBuffers(1, &m_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_buffer);
        
        size_t size= mesh.vertex_buffer_size() + mesh.normal_buffer_size();
        glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_STATIC_DRAW);
        
        // transfere les positions des sommets
        size_t offset= 0;
        size= mesh.vertex_buffer_size();
        glBufferSubData(GL_ARRAY_BUFFER, offset, size, mesh.vertex_buffer());
        // configure l'attribut 0, vec3 position
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset);
        glEnableVertexAttribArray(0);
 
        // transfere les normales des sommets
        offset= offset + size;
        size= mesh.normal_buffer_size();
        glBufferSubData(GL_ARRAY_BUFFER, offset, size, mesh.normal_buffer());
        // configure l'attribut 2, vec3 normal
        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset);
        glEnableVertexAttribArray(2);
 
 
        // instance buffer, position aleatoire des cubes...
        srand(time(NULL));
        
        std::vector<vec3> positions;
        for(int i= 0; i < 50; i++)
        {
            float x= rand() % 11 - 5;
            float y= rand() % 11 - 5;
            float z= rand() % 11 - 5;
            
            positions.push_back(vec3(x *4, y *4, z *4));
        }
        
        m_instance_count= (int) positions.size();
        
        // cree et initialise le buffer d'instance
        glGenBuffers(1, &m_instance_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_instance_buffer);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vec3) * positions.size(), &positions.front().x, GL_STATIC_DRAW);
 
        // configure le vao pour l'attribut d'instance
        // configure l'attribut 1, vec3 instance_position
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, /* offset */ 0);
        glVertexAttribDivisor(1, 1);    // !! c'est la seule difference entre un attribut de sommet et un attribut d'instance !!
        glEnableVertexAttribArray(1);
        
        //
        mesh.release();
        glBindVertexArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
 
        // shaders
        m_program= read_program("tutos/instance_buffer.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() [1/2]

int DrawInstanceBuffer::quit ( )

inlinevirtual

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

Implements App.

Definition at line 113 of file tuto6GL_buffer.cpp.

    {
        release_program(m_program);
        glDeleteVertexArrays(1, &m_vao);
        glDeleteBuffers(1, &m_buffer);
        glDeleteBuffers(1, &m_instance_buffer);
        return 0;
    }

update() [1/2]

int DrawInstanceBuffer::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 122 of file tuto6GL_buffer.cpp.

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

render() [1/2]

int DrawInstanceBuffer::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 tuto6GL_buffer.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());
        
        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, m_instance_count);
        
        return 1;
    }

init() [2/2]

int DrawInstanceBuffer::init ( )

inlinevirtual

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

Implements App.

Definition at line 27 of file tuto_stream.cpp.

    {
        // charge un mesh
        Mesh mesh= read_mesh("data/cube.obj");
        if(mesh == Mesh::error()) return -1;
        
        Point pmin, pmax;
        mesh.bounds(pmin, pmax);
        m_camera.lookat(pmin - Vector(40, 40, 40), pmax + Vector(40, 40, 40));
        
        m_vertex_count= mesh.vertex_count();
 
        // cree les buffers et le vao
        glGenVertexArrays(1, &m_vao);
        glBindVertexArray(m_vao);
        
        // buffer : positions + normals
        glGenBuffers(1, &m_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_buffer);
        
        size_t size= mesh.vertex_buffer_size() + mesh.normal_buffer_size();
        glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_STATIC_DRAW);
        
        // transfere les positions des sommets
        size_t offset_positions= 0;
        size= mesh.vertex_buffer_size();
        glBufferSubData(GL_ARRAY_BUFFER, offset_positions, size, mesh.vertex_buffer());
        // configure l'attribut 0, vec3 position
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset_positions);
        glEnableVertexAttribArray(0);
 
        // transfere les normales des sommets
        size_t offset_normals= offset_positions + size;
        size= mesh.normal_buffer_size();
        glBufferSubData(GL_ARRAY_BUFFER, offset_normals, size, mesh.normal_buffer());
        // configure l'attribut 2, vec3 normal
        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset_normals);
        glEnableVertexAttribArray(2);
        
    // remarque : oui, c'est mal et la suite montre comment le faire correctement !!
        
        // instance buffer, position aleatoire des cubes...
        srand(time(nullptr));
        
        for(int i= 0; i < 1024*1024; i++)
        {
            float x= rand() % 256 - 128;
            float y= rand() % 256 - 128;
            float z= rand() % 256 - 128;
            
            m_positions.push_back(vec3(x *4, y *4, z *4));
        }
        
        
        m_instance_count= int(m_positions.size());
        
        printf("buffer %dKB\n", int(sizeof(vec3) * m_positions.size() / 1024));
        
        // cree et initialise le buffer d'instance
        // version openGL 3, buffer dynamique + glBufferSubData()
        glGenBuffers(1, &m_instance_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, m_instance_buffer);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vec3) * m_positions.size(), m_positions.data(), GL_DYNAMIC_DRAW);
 
        // configure le vao pour l'attribut d'instance
        // configure l'attribut 1, vec3 instance_position
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, /* offset */ 0);
        glVertexAttribDivisor(1, 1);    // !! c'est la seule difference entre un attribut de sommet et un attribut d'instance !!
        glEnableVertexAttribArray(1);
        
        // openGL 4.4, buffer dynamique explicite + map persistant
        glGenBuffers(1, &m_instance_storage);
        glBindBuffer(GL_ARRAY_BUFFER, m_instance_storage);
        glBufferStorage(GL_ARRAY_BUFFER,  sizeof(vec3) * m_positions.size(), nullptr, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
        
        m_storage= glMapBufferRange(GL_ARRAY_BUFFER, 0, sizeof(vec3) * m_positions.size(), 
            GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT);
        if(m_storage == nullptr) 
            return -1;
        
        // cree et initialise un autre vao 
        glGenVertexArrays(1, &m_vao_storage);
        glBindVertexArray(m_vao_storage);
        
        glBindBuffer(GL_ARRAY_BUFFER, m_buffer);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset_positions);
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset_normals);
        glEnableVertexAttribArray(2);
 
        glBindBuffer(GL_ARRAY_BUFFER, m_instance_storage);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, /* offset */ 0);
        glVertexAttribDivisor(1, 1);    // !! c'est la seule difference entre un attribut de sommet et un attribut d'instance !!
        glEnableVertexAttribArray(1);
 
        glBindVertexArray(0);
        
        //
        mesh.release();
        glBindVertexArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
 
        // shaders
        m_program= read_program("tutos/instance_buffer.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/2]

int DrawInstanceBuffer::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_stream.cpp.

    {
        release_program(m_program);
        glDeleteVertexArrays(1, &m_vao);
        glDeleteBuffers(1, &m_buffer);
        glDeleteBuffers(1, &m_instance_buffer);
        return 0;
    }

update() [2/2]

int DrawInstanceBuffer::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 153 of file tuto_stream.cpp.

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

render() [2/2]

int DrawInstanceBuffer::render ( )

inlinevirtual

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

Implements App.

Definition at line 160 of file tuto_stream.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());
        
        static int mode= 0;
        if(key_state(SDLK_SPACE))
        {
            clear_key_state(SDLK_SPACE);
            mode= (mode + 1) % 5;
            printf("mode %d\n", mode);
            
            // alterne entre les 4 solutions de transfert...
        }
        
        // modifie le contenu du buffer d'instances
        if(mode == 0)
        {
            // strategie 1 :
            // recreer le buffer + transferer les donnees
            glBindBuffer(GL_ARRAY_BUFFER, m_instance_buffer);
            glBufferData(GL_ARRAY_BUFFER, sizeof(vec3) * m_positions.size(), m_positions.data(), GL_DYNAMIC_DRAW);
            
            glBindVertexArray(m_vao);
        }
        else if(mode == 1)
        {
            // strategie 2 :
            // transferer les donnees
            glBindBuffer(GL_ARRAY_BUFFER, m_instance_buffer);
            glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vec3) * m_positions.size(), m_positions.data());
            
            glBindVertexArray(m_vao);
        }
        else if(mode == 2)
        {
            // strategie 3 :
            // invalider les donnees + transfert
            glInvalidateBufferData(m_instance_buffer);
            glBindBuffer(GL_ARRAY_BUFFER, m_instance_buffer);
            glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vec3) * m_positions.size(), m_positions.data());
            
            glBindVertexArray(m_vao);
        }
        else if(mode == 3)
        {
            // strategie 4 :
            // persistant map + flush + barrier
            
            std::chrono::high_resolution_clock::time_point copy_start= std::chrono::high_resolution_clock::now();
            memcpy(m_storage, m_positions.data(), sizeof(vec3) * m_positions.size());
            
            std::chrono::high_resolution_clock::time_point copy_stop= std::chrono::high_resolution_clock::now();
            auto copy_time= std::chrono::duration_cast<std::chrono::microseconds>(copy_stop - copy_start).count();
            printf("memcpy  %dK %02dus = %.2fK/s\n", int(sizeof(vec3) * m_positions.size()) / 1024, int(copy_time), float(sizeof(vec3) * m_positions.size() / 1024) / (float(copy_time) / 1000000));
            
            glBindBuffer(GL_ARRAY_BUFFER, m_instance_storage);            
            glFlushMappedBufferRange(GL_ARRAY_BUFFER, 0,  sizeof(vec3) * m_positions.size());
            
            glMemoryBarrier(GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT);
            
            glBindVertexArray(m_vao_storage);
        }
        else
        {
            // pas de modifications
            glBindVertexArray(m_vao);
        }
        
        // draw
        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, std::min(m_instance_count, 4096));
        
        return 1;
    }

---

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

• tutos/tuto6GL_buffer.cpp
• tutos/M2/tuto_stream.cpp