omni::visual::VertexVBO Class Reference

Utility class for storing and drawing VBO data. More...

#include <VertexVBO.h>

Collaboration diagram for omni::visual::VertexVBO:

Public Types
typedef std::vector< Vertex >	vertex_buffer_type
	Vertex buffer type. More...
typedef std::vector< uint32_t >	index_buffer_type
	Index buffer type. More...

Public Member Functions
	VertexVBO ()
	VertexVBO (vertex_buffer_type const &_vertices, index_buffer_type const &_indices)
void	buffer (vertex_buffer_type const &_vertices, index_buffer_type const &_indices)
	Copy buffers to GPU. More...
void	bind () const
	Bind buffer for drawing. More...
void	draw () const
	Draw buffer as triangles. More...
void	draw (uint32_t _numIndices, GLuint _drawType=GL_TRIANGLES) const
	Draw specific indices from buffer as triangles. More...
void	unbind () const
	Unbind buffer. More...
template<typename... ARGS>
void	bindAndDraw (ARGS &&..._args) const
size_t	numIndices () const
	Return number of indices in this buffer. More...
size_t	numTriangles () const
	Number of triangles = number of indices / 3. More...
VBO const &	vertexVbo () const
	Return vertex vertex buffer object. More...
VBO const &	indexVbo () const
	Return index vertex buffer object. More...

Private Attributes
size_t	numIndices_ = 0
std::unique_ptr< VBO >	vertexVbo_
std::unique_ptr< VBO >	indexVbo_

Detailed Description

Utility class for storing and drawing VBO data.

Member Typedef Documentation

typedef std::vector<uint32_t> omni::visual::VertexVBO::index_buffer_type

Index buffer type.

typedef std::vector<Vertex> omni::visual::VertexVBO::vertex_buffer_type

Vertex buffer type.

Constructor & Destructor Documentation

omni::visual::VertexVBO::VertexVBO

(

)

{}

omni::visual::VertexVBO::VertexVBO	(	vertex_buffer_type const &	_vertices,
		index_buffer_type const &	_indices
	)

                                                            {
      buffer(_vertices, _indices);
    }

Member Function Documentation

void omni::visual::VertexVBO::bind

(

)

const

Bind buffer for drawing.

                               {
      withCurrentContext([this](QOpenGLFunctions& _)
      {
        _.glBindBuffer(GL_ARRAY_BUFFER, vertexVbo_->id());
        _.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexVbo_->id());

        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        glEnableClientState(GL_NORMAL_ARRAY);
        glEnableClientState(GL_VERTEX_ARRAY);
      });
    }

template<typename... ARGS>

void omni::visual::VertexVBO::bindAndDraw ( ARGS &&...  _args ) const

inline

                                                 {
          bind();
          draw(_args ...);
          unbind();
        }

void omni::visual::VertexVBO::buffer	(	vertex_buffer_type const &	_vertices,
		index_buffer_type const &	_indices
	)

Copy buffers to GPU.

                                                              {
      vertexVbo_.reset(new VBO());
      indexVbo_.reset(new VBO());

      withCurrentContext([&](QOpenGLFunctions& _)
      {

        // bind VBO in order to use
        _.glBindBuffer(GL_ARRAY_BUFFER, vertexVbo_->id());
        {
          _.glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(Vertex),
                         _vertices.data(), GL_STATIC_DRAW);
        }
        _.glBindBuffer(GL_ARRAY_BUFFER, 0);

        _.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexVbo_->id());
        {
          _.glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                         _indices.size() * sizeof(GLuint), _indices.data(),
                         GL_STATIC_DRAW);
        }
        _.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        numIndices_ = _indices.size();
      });
    }

void omni::visual::VertexVBO::draw

(

)

const

Draw buffer as triangles.

                               {
      draw(numIndices_);
    }

void omni::visual::VertexVBO::draw	(	uint32_t	_numIndices,
		GLuint	_drawType = GL_TRIANGLES
	)		const

Draw specific indices from buffer as triangles.

                                                                      {
      if ((_numElements < 4) || (_numElements > numIndices_)) {
        return;
      }
      withCurrentContext([&](QOpenGLFunctions& _)
      {
        glTexCoordPointer(3, GL_FLOAT, sizeof(Vertex),
                          (void *)Vertex::texCoordOffset());
        glNormalPointer(GL_FLOAT, sizeof(Vertex), (void *)Vertex::normalOffset());
        glVertexPointer(3, GL_FLOAT, sizeof(Vertex), (void *)Vertex::posOffset());
        _.glDrawElements(_drawType, _numElements - 4, GL_UNSIGNED_INT, 0);
      });
    }

VBO const & omni::visual::VertexVBO::indexVbo

(

)

const

Return index vertex buffer object.

                                         {
      return *indexVbo_;
    }

size_t omni::visual::VertexVBO::numIndices

(

)

const

Return number of indices in this buffer.

                                       {
      return numIndices_;
    }

size_t omni::visual::VertexVBO::numTriangles ( ) const

inline

Number of triangles = number of indices / 3.

                                           {
          return numIndices() / 3;
        }

void omni::visual::VertexVBO::unbind

(

)

const

Unbind buffer.

                                 {
      withCurrentContext([this](QOpenGLFunctions& _)
      {
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        glDisableClientState(GL_NORMAL_ARRAY);
        glDisableClientState(GL_VERTEX_ARRAY);

        _.glBindBuffer(GL_ARRAY_BUFFER, 0);
        _.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
      });
    }

VBO const & omni::visual::VertexVBO::vertexVbo

(

)

const

Return vertex vertex buffer object.

                                          {
      return *vertexVbo_;
    }

Field Documentation

std::unique_ptr<VBO> omni::visual::VertexVBO::indexVbo_

private

size_t omni::visual::VertexVBO::numIndices_ = 0

private

std::unique_ptr<VBO> omni::visual::VertexVBO::vertexVbo_

private

---

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

• include/omni/visual/VertexVBO.h
• src/lib/visual/VertexVBO.cpp