SLGLVertexBuffer encapsulates an OpenGL buffer for vertex attributes. More...

#include <SLGLVertexBuffer.h>

Public Member Functions
	SLGLVertexBuffer ()
	Constructor initializing with default values. More...

	~SLGLVertexBuffer ()

void	deleteGL ()
	Deletes all vertex array & vertex buffer objects. More...

void	clear ()
	Calls deleteGL & clears the attributes. More...

SLint	attribIndex (SLGLAttributeType type)
	Returns the vector index if a vertex attribute exists otherwise -1. More...

void	updateAttrib (SLGLAttributeType type, SLint elementSize, void *dataPointer)
	Updates a specific vertex attribute in the VBO. More...

void	updateAttrib (SLGLAttributeType type, SLVuint &data)
	Updates a specific vertex attribute in the VBO. More...

void	updateAttrib (SLGLAttributeType type, SLVfloat &data)
	Updates a specific vertex attribute in the VBO. More...

void	updateAttrib (SLGLAttributeType type, SLVVec2f &data)
	Updates a specific vertex attribute in the VBO. More...

void	updateAttrib (SLGLAttributeType type, SLVVec3f &data)
	Updates a specific vertex attribute in the VBO. More...

void	updateAttrib (SLGLAttributeType type, SLVVec4f &data)
	Updates a specific vertex attribute in the VBO. More...

void	generate (SLuint numVertices, SLGLBufferUsage usage=BU_static, SLbool outputInterleaved=true)
	Generates the VBO. More...

void	bindAndEnableAttrib (SLuint divisor=0) const
	Binds & enables the vertex attribute for OpenGL < 3.0 and during VAO creation. More...

void	disableAttrib ()
	disables the vertex attribute for OpenGL < 3.0 More...

SLuint	id () const

SLuint	size () const

SLVVertexAttrib &	attribs ()

SLbool	outputIsInterleaved () const

Static Public Member Functions
static SLuint	sizeOfType (SLGLBufferType type)
	static total size of all buffers in bytes More...

Static Public Attributes
static SLuint	totalBufferCount = 0

static SLuint	totalBufferSize = 0
	static total no. of buffers in use More...

Protected Attributes
SLuint	_id

SLuint	_numVertices
	OpenGL id of vertex buffer object. More...

SLVVertexAttrib	_attribs
	NO. of vertices in array. More...

SLbool	_outputIsInterleaved
	Vector of vertex attributes. More...

SLbool	_inputIsInterleaved
	Flag if VBO should be generated interleaved. More...

SLuint	_strideBytes
	Flag if VBO should be generated interleaved. More...

SLuint	_sizeBytes
	Distance for interleaved attributes in bytes. More...

SLGLBufferUsage	_usage
	Total size of float VBO in bytes. More...

Detailed Description

SLGLVertexBuffer encapsulates an OpenGL buffer for vertex attributes.

SLGLVertexBuffer is only meant to be used within the SLGLVertexArray class. Attributes can be either be in sequential order (first all positions, then all normals, etc.) or interleaved (all attributes together for one vertex). See SLGLVertexBuffer::generate for more information.
Vertex index buffer are not handled in this class. They are generated in SLGLVertexArray.

Definition at line 44 of file SLGLVertexBuffer.h.

Constructor & Destructor Documentation

◆ SLGLVertexBuffer()

SLGLVertexBuffer::SLGLVertexBuffer ( )

Constructor initializing with default values.

Definition at line 19 of file SLGLVertexBuffer.cpp.

 {
     _id                  = 0;
     _numVertices         = 0;
     _sizeBytes           = 0;
     _outputIsInterleaved = false;
     _usage               = BU_stream;
 }

◆ ~SLGLVertexBuffer()

SLGLVertexBuffer::~SLGLVertexBuffer ( )

inline

Definition at line 48 of file SLGLVertexBuffer.h.

48 { clear(); }

SLGLVertexBuffer::clear

void clear()

Calls deleteGL & clears the attributes.

Definition: SLGLVertexBuffer.cpp:42

Member Function Documentation

◆ attribIndex()

SLint SLGLVertexBuffer::attribIndex ( SLGLAttributeType type )

Returns the vector index if a vertex attribute exists otherwise -1.

Definition at line 48 of file SLGLVertexBuffer.cpp.

 {
     for (SLuint i = 0; i < _attribs.size(); ++i)
         if (_attribs[i].type == type)
             return (SLint)i;
     return -1;
 }

◆ attribs()

SLVVertexAttrib& SLGLVertexBuffer::attribs ( )

inline

Definition at line 98 of file SLGLVertexBuffer.h.

98 { return _attribs; }

◆ bindAndEnableAttrib()

void SLGLVertexBuffer::bindAndEnableAttrib ( SLuint instanceDivisor = 0 ) const

Binds & enables the vertex attribute for OpenGL < 3.0 and during VAO creation.

This method is only used by SLGLVertexArray drawing methods for OpenGL contexts prior to 3.0 where vertex array objects did not exist. This is the additional overhead that had to be done per draw call. For VAO (Vertex Array Objects) this method is only used once at the creation of the VAO. The instanceDivisor number is only used for instanced drawing. For all other usage it is by default 0.

Definition at line 268 of file SLGLVertexBuffer.cpp.

 {
     /////////////////////////////////////////
     // Associate VBO to Attribute location //
     /////////////////////////////////////////
  
     glBindBuffer(GL_ARRAY_BUFFER, _id);
  
     if (_outputIsInterleaved) // Copy attribute data interleaved
     {
         for (auto a : _attribs)
         {
             if (a.location > -1)
             { // Sets the vertex attribute data pointer to its corresponding GLSL variable
                 if (a.dataType == BT_int || a.dataType == BT_uint)
                 {
                     glVertexAttribIPointer((SLuint)a.location,
                                            a.elementSize,
                                            a.dataType,
                                            (SLint)_strideBytes,
                                            (void*)(size_t)a.offsetBytes);
                 }
                 else
                 {
                     glVertexAttribPointer((SLuint)a.location,
                                           a.elementSize,
                                           a.dataType,
                                           GL_FALSE,
                                           (SLint)_strideBytes,
                                           (void*)(size_t)a.offsetBytes);
                 }
  
                 // Tell the attribute to be an array attribute instead of a state variable
                 glEnableVertexAttribArray((SLuint)a.location);
  
                 // Special setting for instanced drawing
                 if (instanceDivisor > 0)
                     glVertexAttribDivisor((SLuint)a.location,
                                           instanceDivisor);
             }
         }
     }
     else // copy attributes buffers sequentially
     {
         for (auto a : _attribs)
         {
             if (a.location > -1)
             {
                 // Sets the vertex attribute data pointer to its corresponding GLSL variable
                 if (a.dataType == BT_int || a.dataType == BT_uint)
                 {
                     glVertexAttribIPointer((SLuint)a.location,
                                            a.elementSize,
                                            a.dataType,
                                            0,
                                            (void*)(size_t)a.offsetBytes);
                 }
                 else
                 {
                     glVertexAttribPointer((SLuint)a.location,
                                           a.elementSize,
                                           a.dataType,
                                           GL_FALSE,
                                           0,
                                           (void*)(size_t)a.offsetBytes);
                 }
  
                 // Tell the attribute to be an array attribute instead of a state variable
                 glEnableVertexAttribArray((SLuint)a.location);
  
                 // Special setting for instanced drawing
                 if (instanceDivisor > 0)
                     glVertexAttribDivisor((SLuint)a.location,
                                           instanceDivisor);
             }
         }
     }
 }

◆ clear()

void SLGLVertexBuffer::clear ( )

Calls deleteGL & clears the attributes.

Definition at line 42 of file SLGLVertexBuffer.cpp.

 {
     deleteGL();
     _attribs.clear();
 }

◆ deleteGL()

void SLGLVertexBuffer::deleteGL ( )

Deletes all vertex array & vertex buffer objects.

Deletes the OpenGL objects for the vertex array and the vertex buffer. The vector _attribs with the attribute information is not cleared.

Definition at line 31 of file SLGLVertexBuffer.cpp.

 {
     if (_id)
     {
         glDeleteBuffers(1, &_id);
         _id = 0;
         totalBufferCount--;
         totalBufferSize -= _sizeBytes;
     }
 }

◆ disableAttrib()

void SLGLVertexBuffer::disableAttrib ( )

disables the vertex attribute for OpenGL < 3.0

This method is only used by SLGLVertexArray drawing methods for OpenGL contexts prior to 3.0 where vertex array objects did not exist. This is the additional overhead that had to be done per draw call.

Definition at line 351 of file SLGLVertexBuffer.cpp.

 {
     if (_attribs.size())
     {
         for (auto a : _attribs)
             if (a.location > -1)
                 glDisableVertexAttribArray((SLuint)a.location);
     }
 }

◆ generate()

void SLGLVertexBuffer::generate	(	SLuint	numVertices,
		SLGLBufferUsage	usage = `BU_static`,
		SLbool	outputInterleaved = `true`
	)

Generates the VBO.

Generates the OpenGL VBO for one or more vertex attributes. If the input data is an interleaved array (all attribute data pointer where identical) also the output buffer will be generated as an interleaved array. Vertex arrays with attributes that are updated can not be interleaved. Vertex attributes with separate arrays can generate an interleaved or a sequential vertex buffer.



 Sequential attribute layout:


           |          Positions          |           Normals           |     TexCoords     |


 Attribs:  |   Position0  |   Position1  |    Normal0   |    Normal1   |TexCoord0|TexCoord1|


 Elements: | PX | PY | PZ | PX | PY | PZ | NX | NY | NZ | NX | NY | NZ | TX | TY | TX | TY |


 Bytes:    |#### #### ####|#### #### ####|#### #### ####|#### #### ####|#### ####|#### ####|


           |                             |                             |


           |<------ offset Normals ----->|                             |


           |<-------------------- offset TexCoords ------------------->|




 Interleaved attribute layout:


           |               Vertex 0                |               Vertex 1                |


 Attribs:  |   Position0  |    Normal0   |TexCoord0|   Position1  |    Normal1   |TexCoord1|


 Elements: | PX | PY | PZ | NX | NY | NZ | TX | TY | PX | PY | PZ | NX | NY | NZ | TX | TY |


 Bytes:    |#### #### ####|#### #### ####|#### ####|#### #### ####|#### #### ####|#### ####|


           |              |              |         |


           |<-offsetN=32->|              |         |


           |<------- offsetTC=32 ------->|         |


           |                                       |


           |<---------- strideBytes=32 ----------->|

Definition at line 122 of file SLGLVertexBuffer.cpp.

 {
     assert(numVertices);
  
     // if buffers exist delete them first
     deleteGL();
  
     _numVertices         = numVertices;
     _usage               = usage;
     _outputIsInterleaved = outputInterleaved;
  
     // Generate the vertex buffer object
     if (_attribs.size())
     {
         glGenBuffers(1, &_id);
         glBindBuffer(GL_ARRAY_BUFFER, _id);
     }
  
     // Check first if all attribute data pointer point to the same interleaved data
     _inputIsInterleaved = false;
     if (_attribs.size() > 1)
     {
         _inputIsInterleaved = true;
         for (auto a : _attribs)
         {
             if (a.dataPointer != _attribs[0].dataPointer)
             {
                 _inputIsInterleaved = false;
                 break;
             }
         }
     }
  
     ///////////////////////////////////////////////////////
     // Calculate total VBO size & attribute stride & offset
     ///////////////////////////////////////////////////////
  
     _sizeBytes   = 0;
     _strideBytes = 0;
  
     if (_inputIsInterleaved)
     {
         _outputIsInterleaved = true;
  
         for (SLuint i = 0; i < _attribs.size(); ++i)
         {
             SLuint elementSizeBytes = (SLuint)_attribs[i].elementSize *
                                       sizeOfType(_attribs[i].dataType);
             _attribs[i].offsetBytes     = _strideBytes;
             _attribs[i].bufferSizeBytes = elementSizeBytes * _numVertices;
             _sizeBytes += _attribs[i].bufferSizeBytes;
             _strideBytes += elementSizeBytes;
         }
     }
     else // input is in separate attribute data blocks
     {
         for (SLuint i = 0; i < _attribs.size(); ++i)
         {
             SLuint elementSizeBytes = (SLuint)_attribs[i].elementSize *
                                       sizeOfType(_attribs[i].dataType);
             if (_outputIsInterleaved)
                 _attribs[i].offsetBytes = _strideBytes;
             else
                 _attribs[i].offsetBytes = _sizeBytes;
             _attribs[i].bufferSizeBytes = elementSizeBytes * _numVertices;
             _sizeBytes += _attribs[i].bufferSizeBytes;
             if (_outputIsInterleaved) _strideBytes += elementSizeBytes;
         }
     }
  
     //////////////////////////////
     // Generate VBO for Attributes
     //////////////////////////////
  
     if (_inputIsInterleaved)
     {
         // generate the interleaved VBO buffer on the GPU
         glBufferData(GL_ARRAY_BUFFER,
                      _sizeBytes,
                      _attribs[0].dataPointer,
                      _usage);
     }
     else // input is in separate attribute data block
     {
         if (_outputIsInterleaved) // Copy attribute data interleaved
         {
             SLVuchar data;
             data.resize(_sizeBytes);
             for (auto a : _attribs)
             {
                 SLuint elementSizeBytes = (SLuint)a.elementSize *
                                           sizeOfType(a.dataType);
  
                 // Copy attributes interleaved
                 for (SLuint v = 0; v < _numVertices; ++v)
                 {
                     SLuint iDst = v * _strideBytes + a.offsetBytes;
                     SLuint iSrc = v * elementSizeBytes;
                     for (SLuint b = 0; b < elementSizeBytes; ++b)
                         data[iDst + b] = ((SLuchar*)a.dataPointer)[iSrc + b];
                 }
  
                 // generate the interleaved VBO buffer on the GPU
                 glBufferData(GL_ARRAY_BUFFER,
                              _sizeBytes,
                              &data[0],
                              _usage);
             }
         }
         else // copy attributes buffers sequentially
         {
             // allocate the VBO buffer on the GPU
             glBufferData(GL_ARRAY_BUFFER,
                          _sizeBytes,
                          nullptr,
                          _usage);
  
             for (auto a : _attribs)
             {
                 if (a.location > -1)
                 {
                     // Copies the attributes data at the right offset into the VBO
                     glBufferSubData(GL_ARRAY_BUFFER,
                                     a.offsetBytes,
                                     a.bufferSizeBytes,
                                     a.dataPointer);
                 }
             }
         }
     }
  
     totalBufferCount++;
     totalBufferSize += _sizeBytes;
     GET_GL_ERROR;
 }

◆ id()

SLuint SLGLVertexBuffer::id ( ) const

inline

Definition at line 96 of file SLGLVertexBuffer.h.

96 { return _id; }

◆ outputIsInterleaved()

SLbool SLGLVertexBuffer::outputIsInterleaved ( ) const

inline

Definition at line 99 of file SLGLVertexBuffer.h.

99 { return _outputIsInterleaved; }

◆ size()

SLuint SLGLVertexBuffer::size ( ) const

inline

Definition at line 97 of file SLGLVertexBuffer.h.

97 { return _id; }

◆ sizeOfType()

SLuint SLGLVertexBuffer::sizeOfType ( SLGLBufferType type )

static

static total size of all buffers in bytes

Returns the size in byte depending off the buffer type.

Returns the size of a buffer data type

Definition at line 362 of file SLGLVertexBuffer.cpp.

 {
     switch (type)
     {
         case BT_float: return sizeof(SLfloat);
         case BT_int: return sizeof(SLint);
         case BT_ubyte: return sizeof(SLuchar);
         case BT_ushort: return sizeof(SLushort);
         case BT_uint: return sizeof(SLint);
         default: SL_EXIT_MSG("Invalid buffer data type");
     }
     return 0;
 }

◆ updateAttrib() [1/6]

void SLGLVertexBuffer::updateAttrib	(	SLGLAttributeType	type,
		SLint	elementSize,
		void *	dataPointer
	)

Updates a specific vertex attribute in the VBO.

Updates the specified vertex attribute. This works only for sequential attributes and not for interleaved attributes. This is used e.g. for meshes with vertex skinning. See SLMesh::draw where we have joint attributes.

Definition at line 60 of file SLGLVertexBuffer.cpp.

 {
     assert(dataPointer && "No data pointer passed");
     assert(elementSize > 0 && elementSize < 5 && "Element size invalid");
  
     // Get attribute index and check element size
     SLint index = attribIndex(type);
     if (index == -1)
         SL_EXIT_MSG("Attribute type does not exist in VBO.");
     if (_attribs[(SLuint)index].elementSize != elementSize)
         SL_EXIT_MSG("Attribute element size differs.");
     if (_outputIsInterleaved)
         SL_EXIT_MSG("Interleaved buffers can't be updated.");
  
     // Generate the vertex buffer object if there is none
     if (index && !_id)
         glGenBuffers(1, &_id);
  
     _attribs[(SLuint)index].dataPointer = dataPointer;
  
     ///////////////////////////////////////////////
     // copy sub-data into existing buffer object //
     ///////////////////////////////////////////////
  
     glBindBuffer(GL_ARRAY_BUFFER, _id);
     glBufferSubData(GL_ARRAY_BUFFER,
                     _attribs[(SLuint)index].offsetBytes,
                     _attribs[(SLuint)index].bufferSizeBytes,
                     _attribs[(SLuint)index].dataPointer);
     GET_GL_ERROR;
 }

◆ updateAttrib() [2/6]

void SLGLVertexBuffer::updateAttrib	(	SLGLAttributeType	type,
		SLVfloat &	data
	)

inline

Updates a specific vertex attribute in the VBO.

Definition at line 69 of file SLGLVertexBuffer.h.

70 { updateAttrib(type, 1, (void*)&data[0]); }

SLGLVertexBuffer::updateAttrib

void updateAttrib(SLGLAttributeType type, SLint elementSize, void *dataPointer)

Updates a specific vertex attribute in the VBO.

Definition: SLGLVertexBuffer.cpp:60

◆ updateAttrib() [3/6]

void SLGLVertexBuffer::updateAttrib	(	SLGLAttributeType	type,
		SLVuint &	data
	)

inline

Updates a specific vertex attribute in the VBO.

Definition at line 65 of file SLGLVertexBuffer.h.

66 { updateAttrib(type, 1, (void*)&data[0]); }

◆ updateAttrib() [4/6]

void SLGLVertexBuffer::updateAttrib	(	SLGLAttributeType	type,
		SLVVec2f &	data
	)

inline

Updates a specific vertex attribute in the VBO.

Definition at line 73 of file SLGLVertexBuffer.h.

74 { updateAttrib(type, 2, (void*)&data[0]); }

◆ updateAttrib() [5/6]

void SLGLVertexBuffer::updateAttrib	(	SLGLAttributeType	type,
		SLVVec3f &	data
	)

inline

Updates a specific vertex attribute in the VBO.

Definition at line 77 of file SLGLVertexBuffer.h.

78 { updateAttrib(type, 3, (void*)&data[0]); }

◆ updateAttrib() [6/6]

void SLGLVertexBuffer::updateAttrib	(	SLGLAttributeType	type,
		SLVVec4f &	data
	)

inline

Updates a specific vertex attribute in the VBO.

Definition at line 81 of file SLGLVertexBuffer.h.

82 { updateAttrib(type, 4, (void*)&data[0]); }

Member Data Documentation

◆ _attribs

SLVVertexAttrib SLGLVertexBuffer::_attribs

protected

NO. of vertices in array.

Definition at line 113 of file SLGLVertexBuffer.h.

◆ _id

SLuint SLGLVertexBuffer::_id

protected

Definition at line 111 of file SLGLVertexBuffer.h.

◆ _inputIsInterleaved

SLbool SLGLVertexBuffer::_inputIsInterleaved

protected

Flag if VBO should be generated interleaved.

Definition at line 115 of file SLGLVertexBuffer.h.

◆ _numVertices

SLuint SLGLVertexBuffer::_numVertices

protected

OpenGL id of vertex buffer object.

Definition at line 112 of file SLGLVertexBuffer.h.

◆ _outputIsInterleaved

SLbool SLGLVertexBuffer::_outputIsInterleaved

protected

Vector of vertex attributes.

Definition at line 114 of file SLGLVertexBuffer.h.

◆ _sizeBytes

SLuint SLGLVertexBuffer::_sizeBytes

protected

Distance for interleaved attributes in bytes.

Definition at line 117 of file SLGLVertexBuffer.h.

◆ _strideBytes

SLuint SLGLVertexBuffer::_strideBytes

protected

Flag if VBO should be generated interleaved.

Definition at line 116 of file SLGLVertexBuffer.h.

◆ _usage

SLGLBufferUsage SLGLVertexBuffer::_usage

protected

Total size of float VBO in bytes.

Definition at line 118 of file SLGLVertexBuffer.h.

◆ totalBufferCount

SLuint SLGLVertexBuffer::totalBufferCount = 0

static

Definition at line 104 of file SLGLVertexBuffer.h.

◆ totalBufferSize

SLuint SLGLVertexBuffer::totalBufferSize = 0

static

static total no. of buffers in use

Definition at line 105 of file SLGLVertexBuffer.h.

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SLGLVertexBuffer()

◆ ~SLGLVertexBuffer()

Member Function Documentation

◆ attribIndex()

◆ attribs()

◆ bindAndEnableAttrib()

◆ clear()

◆ deleteGL()

◆ disableAttrib()

◆ generate()

◆ id()

◆ outputIsInterleaved()

◆ size()

◆ sizeOfType()

◆ updateAttrib() [1/6]

◆ updateAttrib() [2/6]

◆ updateAttrib() [3/6]

◆ updateAttrib() [4/6]

◆ updateAttrib() [5/6]

◆ updateAttrib() [6/6]

Member Data Documentation

◆ _attribs

◆ _id

◆ _inputIsInterleaved

◆ _numVertices

◆ _outputIsInterleaved

◆ _sizeBytes

◆ _strideBytes

◆ _usage

◆ totalBufferCount

◆ totalBufferSize