SLGLVertexArray Class Reference

SLGLVertexArray encapsulates the core OpenGL drawing. More...

#include <SLGLVertexArray.h>

Inheritance diagram for SLGLVertexArray:

Public Member Functions
	SLGLVertexArray ()
	~SLGLVertexArray ()
void	deleteGL ()
	Deletes all vertex array & vertex buffer objects. More...
void	clearAttribs ()
	Clears the attribute definition. More...
SLuint	vaoID () const
	Returns either the VAO id or the VBO id. More...
SLuint	tfoID () const
	Returns the TFO id. More...
void	setAttrib (SLGLAttributeType type, SLint elementSize, SLint location, void *dataPointer, SLGLBufferType dataType=BT_float)
	Adds a vertex attribute with data pointer and an element size. More...
void	setAttrib (SLGLAttributeType type, SLint location, SLVuint *data)
	Adds a vertex attribute with vector of SLuint. More...
void	setAttrib (SLGLAttributeType type, SLint location, SLVfloat *data)
	Adds a vertex attribute with vector of SLfloat. More...
void	setAttrib (SLGLAttributeType type, SLint location, SLVVec2f *data)
	Adds a vertex attribute with vector of SLVec2f. More...
void	setAttrib (SLGLAttributeType type, SLint location, SLVVec3f *data)
	Adds a vertex attribute with vector of SLVec3f. More...
void	setAttrib (SLGLAttributeType type, SLint location, SLVVec4f *data)
	Adds a vertex attribute with vector of SLVec4f. More...
void	setAttrib (SLGLAttributeType type, SLint location, SLVVec4i *data)
	Adds a vertex attribute with vector of SLVec4i. More...
void	setIndices (SLuint numIndicesElements, SLGLBufferType indexDataType, void *indexDataElements, SLuint numIndicesEdges=0, void *indexDataEdges=nullptr)
	Adds the index array for indexed element drawing. More...
void	setIndices (SLVubyte *indicesElements, SLVubyte *indicesEdges=nullptr)
	Adds the index array for indexed element drawing with a vector of ubyte. More...
void	setIndices (SLVushort *indicesElements, SLVushort *indicesEdges=nullptr)
	Adds the index array for indexed element drawing with a vector of ushort. More...
void	setIndices (SLVuint *indicesElements, SLVuint *indicesEdges=nullptr)
	Adds the index array for indexed element drawing with a vector of uint. More...
void	setInstanceVBO (SLGLVertexBuffer *vbo, SLuint divisor=0)
	Attach a VBO that has been created outside of this VAO. 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, SLuint divisor=0)
	Generates the VA & VB objects for a NO. of vertices. More...
void	generateTF (SLuint numVertices, SLGLBufferUsage usage=BU_static, SLbool outputInterleaved=true, SLuint divisor=0)
	Generates the VA & VB & TF objects. More...
void	beginTF (SLuint tfoID)
	Begin transform feedback. More...
void	endTF ()
	End transform feedback. More...
void	drawElementsAs (SLGLPrimitiveType primitiveType, SLuint numIndexes=0, SLuint indexOffsetBytes=0)
	Draws the VAO by element indices with a primitive type. More...
void	drawArrayAs (SLGLPrimitiveType primitiveType, SLint firstVertex=0, SLsizei countVertices=0)
	Draws the VAO as an array with a primitive type. More...
void	drawElementsInstanced (SLGLPrimitiveType primitiveType, SLuint countInstance=0, SLuint numIndexes=0, SLuint indexOffset=0)
	Draws the VAO as an array with instance primitive type. More...
void	drawEdges (SLCol4f color, SLfloat lineWidth=1.0f)
	Draws the hard edges of the VAO with the edge indices. More...
SLuint	numVertices () const
SLuint	numIndicesElements () const
SLuint	numIndicesEdges () const
SLGLVertexBuffer *	vbo ()

Static Public Attributes
static SLuint	totalDrawCalls = 0
static SLuint	totalPrimitivesRendered = 0
	static total no. of draw calls More...

Protected Attributes
SLuint	_instances
	static total no. of primitives rendered More...
SLuint	_vaoID
	Number of instances of drawing. More...
SLuint	_tfoID
	OpenGL id of vertex array object. More...
SLuint	_numVertices
	OpenGL id of transform feedback object. More...
SLGLVertexBuffer	_vbo
	NO. of vertices in array. More...
SLuint	_idVBOIndices
	Vertex buffer object for float attributes. More...
size_t	_numIndicesElements
	OpenGL id of index vbo. More...
void *	_indexDataElements
	NO. of vertex indices in array for triangles, lines or points. More...
size_t	_numIndicesEdges
	Pointer to index data for elements. More...
void *	_indexDataEdges
	NO. of vertex indices in array for hard edges. More...
SLGLBufferType	_indexDataType
	Pointer to index data for hard edges. More...
SLGLVertexBuffer *	_instanceVbo
	index data type (ubyte, ushort, uint) More...
SLuint	_instanceDivisor
	Vertex buffer object containing the positions for instanced drawing. More...

Detailed Description

SLGLVertexArray encapsulates the core OpenGL drawing.

An SLGLVertexArray instance handles all OpenGL drawing with an OpenGL Vertex Array Object (VAO), a vertex buffer objects (VBO) for the attributes and an index buffer for element drawing. Attributes can be stored in a float VBO of type SLGLVertexBuffer.
VAOs where introduces OpenGL 3.0 and reduce the overhead per draw call. All vertex attributes (e.g. position, normals, texture coords, etc.) must be float at the input. All float attributes will be in one VBO (_vbo). Vertices can be drawn either directly as in the array (SLGLVertexArray::drawArrayAs) or by element (SLGLVertexArray::drawElementsAs) with a separate indices buffer.
The setup of a VAO has multiple steps:

• Define one ore more attributes with SLGLVertexArray::setAttrib.
• Define the index array for element drawing with SLGLVertexArray::setIndices.
• Generate the OpenGL VAO and VBO with SLGLVertexArray::generate.
  It is important that the data structures passed in SLGLVertexArray::setAttrib and SLGLVertexArray::setIndices are still present when generate is called. The VAO has no or one active index buffer. For drawArrayAs no indices are needed. For drawElementsAs the index buffer is used. For triangle meshes also hard edges are generated. Their indices are stored behind the indices of the triangles. See SLMesh::computeHardEdgesIndices for more infos on hard edges.

Definition at line 39 of file SLGLVertexArray.h.

Constructor & Destructor Documentation

SLGLVertexArray()

SLGLVertexArray::SLGLVertexArray

(

)

Constructor initializing with default values

Definition at line 22 of file SLGLVertexArray.cpp.

{
    _vaoID = 0;
    _vbo.clear();
    _idVBOIndices       = 0;
    _numIndicesElements = 0;
    _numIndicesEdges    = 0;
    _numVertices        = 0;
    _indexDataElements  = nullptr;
    _indexDataEdges     = nullptr;
    _instanceVbo        = nullptr;
}

~SLGLVertexArray()

SLGLVertexArray::~SLGLVertexArray ( )

inline

Definition at line 43 of file SLGLVertexArray.h.

{ deleteGL(); }

Member Function Documentation

beginTF()

void SLGLVertexArray::beginTF

(

SLuint

tfoID

)

Begin transform feedback.

Discard the rendering because we just compute next position with the transform feedback. We need to bind a transform feedback object but not the same from this vao, because we want to read from one vao and write on another.

Definition at line 364 of file SLGLVertexArray.cpp.

{
    // Disable rendering
    glEnable(GL_RASTERIZER_DISCARD);
 
    // Bind the feedback object for the buffers to be drawn next
    glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfoID);
 
    // Draw points from input buffer with transform feedback
    glBeginTransformFeedback(GL_POINTS);
}

clearAttribs()

void SLGLVertexArray::clearAttribs ( )

inline

Clears the attribute definition.

Definition at line 49 of file SLGLVertexArray.h.

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

deleteGL()

void SLGLVertexArray::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 38 of file SLGLVertexArray.cpp.

{
    if (_vaoID)
        glDeleteVertexArrays(1, &_vaoID);
    _vaoID = 0;
 
    if (_vbo.id())
        _vbo.clear();
 
    if (_idVBOIndices)
    {
        glDeleteBuffers(1, &_idVBOIndices);
        _idVBOIndices = 0;
        SLGLVertexBuffer::totalBufferCount--;
        SLGLVertexBuffer::totalBufferSize -= (SLuint)_numIndicesElements *
                                             (SLuint)SLGLVertexBuffer::sizeOfType(_indexDataType);
    }
}

drawArrayAs()

void SLGLVertexArray::drawArrayAs	(	SLGLPrimitiveType	primitiveType,
		SLint	firstVertex = 0,
		SLsizei	countVertices = 0
	)

Draws the VAO as an array with a primitive type.

Draws the vertex attributes as a specified primitive type as the vertices are defined in the attribute arrays.

Definition at line 442 of file SLGLVertexArray.cpp.

{
    assert((_vbo.id()) && "No VBO generated for VAO.");
 
    glBindVertexArray(_vaoID);
 
    if (countVertices == 0)
        countVertices = (SLsizei)_numVertices;
 
    //////////////////////////////////
    glDrawArrays(primitiveType,
                 firstVertex,
                 countVertices);
    //////////////////////////////////
 
    // Update statistics
    totalDrawCalls++;
    SLint numVertices = countVertices - firstVertex;
    switch (primitiveType)
    {
        case PT_triangles:
            totalPrimitivesRendered += (numVertices / 3);
            break;
        case PT_lines:
            totalPrimitivesRendered += (numVertices / 2);
            break;
        case PT_points:
            totalPrimitivesRendered += numVertices;
            break;
        default: break;
    }
 
    glBindVertexArray(0);
 
    GET_GL_ERROR;
}

drawEdges()

void SLGLVertexArray::drawEdges	(	SLCol4f	color,
		SLfloat	lineWidth = 1.0f
	)

Draws the hard edges of the VAO with the edge indices.

Draws the hard edges with the specified color. The VAO has no or one active index buffer. For drawArrayAs no indices are needed. For drawElementsAs the index buffer is used. For triangle meshes also hard edges are generated. Their indices are stored behind the indices of the triangles.

Definition at line 540 of file SLGLVertexArray.cpp.

{
    if (!_vbo.id())
        SL_EXIT_MSG("No VBO generated for VAO in drawArrayAsColored.");
 
    // Prepare shader
    SLGLProgram* sp      = SLGLProgramManager::get(SP_colorUniform);
    SLGLState*   stateGL = SLGLState::instance();
    sp->useProgram();
    sp->uniformMatrix4fv("u_mMatrix", 1, (SLfloat*)&stateGL->modelMatrix);
    sp->uniformMatrix4fv("u_vMatrix", 1, (SLfloat*)&stateGL->viewMatrix);
    sp->uniformMatrix4fv("u_pMatrix", 1, (SLfloat*)&stateGL->projectionMatrix);
    sp->uniform1f("u_oneOverGamma", 1.0f);
    stateGL->currentMaterial(nullptr);
 
    // Set uniform color
    glUniform4fv(sp->getUniformLocation("u_matDiff"), 1, (SLfloat*)&color);
 
#if not defined(SL_GLES) && not defined(SL_EMSCRIPTEN)
    if (lineWidth != 1.0f)
        glLineWidth(lineWidth);
#endif
 
    //////////////////////////////////////////////////////
    drawElementsAs(PT_lines,
                   (SLuint)_numIndicesEdges,
                   (SLuint)_numIndicesElements);
    //////////////////////////////////////////////////////
 
#if not defined(SL_GLES) && not defined(SL_EMSCRIPTEN)
    if (lineWidth != 1.0f)
        glLineWidth(1.0f);
#endif
 
    GET_GL_ERROR;
}

drawElementsAs()

void SLGLVertexArray::drawElementsAs	(	SLGLPrimitiveType	primitiveType,
		SLuint	numIndexes = 0,
		SLuint	indexOffset = 0
	)

Draws the VAO by element indices with a primitive type.

Draws the vertex attributes as a specified primitive type by elements with the indices from the index buffer defined in setIndices.

Definition at line 394 of file SLGLVertexArray.cpp.

{
    assert(_numIndicesElements && _idVBOIndices && "No index VBO generated for VAO");
 
    // From OpenGL 3.0 on we have the OpenGL Vertex Arrays
    // Binding the VAO saves all the commands after the else (per draw call!)
    glBindVertexArray(_vaoID);
    GET_GL_ERROR;
 
    // Do the draw call with indices
    if (numIndexes == 0)
        numIndexes = (SLuint)_numIndicesElements;
 
    SLuint indexTypeSize = SLGLVertexBuffer::sizeOfType(_indexDataType);
 
    /////////////////////////////////////////////////////////////////////
    glDrawElements(primitiveType,
                   (SLsizei)numIndexes,
                   _indexDataType,
                   (void*)(size_t)(indexOffset * (SLuint)indexTypeSize));
    /////////////////////////////////////////////////////////////////////
 
    GET_GL_ERROR;
    totalDrawCalls++;
    switch (primitiveType)
    {
        case PT_triangles:
            totalPrimitivesRendered += (numIndexes / 3);
            break;
        case PT_lines:
            totalPrimitivesRendered += (numIndexes / 2);
            break;
        case PT_points:
            totalPrimitivesRendered += numIndexes;
            break;
        default: break;
    }
 
    glBindVertexArray(0);
    GET_GL_ERROR;
}

drawElementsInstanced()

void SLGLVertexArray::drawElementsInstanced	(	SLGLPrimitiveType	primitiveType,
		SLuint	countInstances = 0,
		SLuint	numIndexes = 0,
		SLuint	indexOffset = 0
	)

Draws the VAO as an array with instance primitive type.

Wrapper around glDrawElementsInstanced using a second VBO (_instanceVbo) that contains all positions for the instances. This used e.g. for SLParticleSystems on systems without geometry shaders.

Definition at line 485 of file SLGLVertexArray.cpp.

{
    assert(_numIndicesElements &&
           _idVBOIndices &&
           "No index VBO generated for VAO");
 
    // From OpenGL 3.0 on we have the OpenGL Vertex Arrays
    // Binding the VAO saves all the commands after the else (per draw call!)
    glBindVertexArray(_vaoID);
    GET_GL_ERROR;
 
    // Do the draw call with indices
    if (numIndexes == 0)
        numIndexes = (SLuint)_numIndicesElements;
 
    SLuint indexTypeSize = SLGLVertexBuffer::sizeOfType(_indexDataType);
 
    ////////////////////////////////////////////////////////
    glDrawElementsInstanced(primitiveType,
                            (GLsizei)numIndexes,
                            _indexDataType,
                            (void*)(size_t)(indexOffset * (SLuint)indexTypeSize),
                            (GLsizei)countInstances);
    ////////////////////////////////////////////////////////
 
    GET_GL_ERROR;
 
    // Update statistics
    totalDrawCalls++;
    switch (primitiveType)
    {
        case PT_triangles:
            totalPrimitivesRendered += (numIndexes / 3);
            break;
        case PT_lines:
            totalPrimitivesRendered += (numIndexes / 2);
            break;
        case PT_points:
            totalPrimitivesRendered += numIndexes;
            break;
        default: break;
    }
    glBindVertexArray(0);
 
    GET_GL_ERROR;
}

endTF()

void SLGLVertexArray::endTF

(

)

End transform feedback.

We activate back the rendering and stop the transform feedback.

Definition at line 379 of file SLGLVertexArray.cpp.

{
    // End transform feedback
    glEndTransformFeedback();
 
    // Enable rendering
    glDisable(GL_RASTERIZER_DISCARD);
 
    // Un-bind the feedback object.
    glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
}

generate()

void SLGLVertexArray::generate	(	SLuint	numVertices,
		SLGLBufferUsage	usage = BU_static,
		SLbool	outputInterleaved = true,
		SLuint	divisor = 0
	)

Generates the VA & VB objects for a NO. of vertices.

Generates the OpenGL objects for the vertex array and the vertex buffer object. 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   |  UV1_0  |  UV1_1  |


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


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


           |                             |                             |


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


           |<----------------------- offset UVs ---------------------->|




 Interleaved attribute layout:


           |               Vertex 0                |               Vertex 1                |


 Attribs:  |   Position0  |    Normal0   |  UV1_0  |   Position1  |    Normal1   |  UV1_1  |


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


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


           |              |              |         |


           |<-offsetN=32->|              |         |


           |<------- offsetUV=32 ------->|         |


           |                                       |


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

The VAO has no or one active index buffer. For drawArrayAs no indices are needed. For drawElementsAs the index buffer is used. For triangle meshes also hard edges are generated. Their indices are stored behind the indices of the triangles.

Definition at line 189 of file SLGLVertexArray.cpp.

{
    assert(numVertices);
 
    // if buffers exist delete them first
    deleteGL();
 
    _numVertices = numVertices;
 
    // Generate and bind VAO
    glGenVertexArrays(1, &_vaoID);
    glBindVertexArray(_vaoID);
 
    ///////////////////////////////
    // Create Vertex Buffer Objects
    ///////////////////////////////
 
    // Generate the vertex buffer object for float attributes
    if (_vbo.attribs().size())
    {
        _vbo.generate(numVertices, usage, outputInterleaved);
        _vbo.bindAndEnableAttrib(divisor);
    }
 
    if (_instanceVbo != nullptr)
    {
        _instanceVbo->bindAndEnableAttrib(_instanceDivisor);
    }
 
    /////////////////////////////////////////////////////////////////
    // Create Element Array Buffer for Indices for elements and edges
    /////////////////////////////////////////////////////////////////
 
    if (_numIndicesElements && _indexDataElements &&
        _numIndicesEdges && _indexDataEdges)
    {
        // create temp. buffer with both index arrays
        SLuint typeSize  = SLGLVertexBuffer::sizeOfType(_indexDataType);
        SLuint tmBufSize = (SLuint)(_numIndicesElements + _numIndicesEdges) *
                           (SLuint)typeSize;
        SLubyte* tmpBuf = new SLubyte[tmBufSize];
        memcpy(tmpBuf,
               _indexDataElements,
               _numIndicesElements * (SLuint)typeSize);
        memcpy(tmpBuf + _numIndicesElements * (SLuint)typeSize,
               _indexDataEdges,
               _numIndicesEdges * (SLuint)typeSize);
 
        glGenBuffers(1, &_idVBOIndices);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
                     _idVBOIndices);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                     tmBufSize,
                     tmpBuf,
                     GL_STATIC_DRAW);
        SLGLVertexBuffer::totalBufferCount++;
        SLGLVertexBuffer::totalBufferSize += tmBufSize;
        delete[] tmpBuf;
    }
    else if (_numIndicesElements && _indexDataElements) // for elements only
    {
        SLuint typeSize = SLGLVertexBuffer::sizeOfType(_indexDataType);
        glGenBuffers(1, &_idVBOIndices);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _idVBOIndices);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                     (GLsizeiptr)_numIndicesElements * (SLuint)typeSize,
                     _indexDataElements,
                     GL_STATIC_DRAW);
        SLGLVertexBuffer::totalBufferCount++;
        SLGLVertexBuffer::totalBufferSize += (SLuint)_numIndicesElements *
                                             (SLuint)typeSize;
    }
 
    glBindVertexArray(0);
    GET_GL_ERROR;
}

generateTF()

void SLGLVertexArray::generateTF	(	SLuint	numVertices,
		SLGLBufferUsage	usage = BU_static,
		SLbool	outputInterleaved = true,
		SLuint	divisor = 0
	)

Generates the VA & VB & TF objects.

Same as generate but with transform feedback

Definition at line 270 of file SLGLVertexArray.cpp.

{
    assert(numVertices);
 
    // if buffers exist delete them first
    deleteGL();
 
    _numVertices = numVertices;
 
    // Generate TFO
    glGenTransformFeedbacks(1, &_tfoID);
 
    // Generate and bind VAO
    glGenVertexArrays(1, &_vaoID);
    glBindVertexArray(_vaoID);
 
    ///////////////////////////////
    // Create Vertex Buffer Objects
    ///////////////////////////////
 
    // Generate the vertex buffer object for float attributes
    if (_vbo.attribs().size())
    {
        _vbo.generate(numVertices, usage, outputInterleaved);
        _vbo.bindAndEnableAttrib(divisor);
    }
 
    // ???
    if (_instanceVbo != nullptr)
    {
        _instanceVbo->bindAndEnableAttrib(_instanceDivisor);
    }
 
    ///////////////////////////////
    // Bind transform feedback
    ///////////////////////////////
 
    glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, _tfoID);
    glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, _vbo.id());
 
    /////////////////////////////////////////////////////////////////
    // Create Element Array Buffer for Indices for elements and edges
    /////////////////////////////////////////////////////////////////
 
    if (_numIndicesElements && _indexDataElements &&
        _numIndicesEdges && _indexDataEdges)
    {
        // create temp. buffer with both index arrays
        SLuint typeSize  = (SLuint)SLGLVertexBuffer::sizeOfType(_indexDataType);
        SLuint tmBufSize = (SLuint)(_numIndicesElements + _numIndicesEdges) *
                           (SLuint)typeSize;
        SLubyte* tmpBuf = new SLubyte[tmBufSize];
        memcpy(tmpBuf,
               _indexDataElements,
               _numIndicesElements * (SLuint)typeSize);
        memcpy(tmpBuf + _numIndicesElements * (SLuint)typeSize,
               _indexDataEdges,
               _numIndicesEdges * (SLuint)typeSize);
 
        glGenBuffers(1, &_idVBOIndices);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _idVBOIndices);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                     tmBufSize,
                     tmpBuf,
                     GL_STATIC_DRAW);
        SLGLVertexBuffer::totalBufferCount++;
        SLGLVertexBuffer::totalBufferSize += tmBufSize;
        delete[] tmpBuf;
    }
    else if (_numIndicesElements && _indexDataElements) // for elements only
    {
        SLuint typeSize = SLGLVertexBuffer::sizeOfType(_indexDataType);
        glGenBuffers(1, &_idVBOIndices);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _idVBOIndices);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                     (GLsizeiptr)_numIndicesElements * (SLuint)typeSize,
                     _indexDataElements,
                     GL_STATIC_DRAW);
        SLGLVertexBuffer::totalBufferCount++;
        SLGLVertexBuffer::totalBufferSize += (SLuint)_numIndicesElements *
                                             (SLuint)typeSize;
    }
 
    glBindVertexArray(0);
    GET_GL_ERROR;
}

numIndicesEdges()

SLuint SLGLVertexArray::numIndicesEdges ( ) const

inline

Definition at line 206 of file SLGLVertexArray.h.

{ return (SLuint)_numIndicesEdges; }

numIndicesElements()

SLuint SLGLVertexArray::numIndicesElements ( ) const

inline

Definition at line 205 of file SLGLVertexArray.h.

{ return (SLuint)_numIndicesElements; }

numVertices()

SLuint SLGLVertexArray::numVertices ( ) const

inline

Definition at line 204 of file SLGLVertexArray.h.

{ return _numVertices; }

setAttrib() [1/7]

void SLGLVertexArray::setAttrib	(	SLGLAttributeType	type,
		SLint	elementSize,
		SLint	location,
		void *	dataPointer,
		SLGLBufferType	dataType = BT_float
	)

Adds a vertex attribute with data pointer and an element size.

Defines a vertex attribute for the later generation. It must be of a specific SLVertexAttribType. Each attribute can appear only once in an vertex array. If all attributes of a vertex array have the same data pointer the data input will be interpreted as an interleaved array. See example in SLGLOculus::init. Be aware that the VBO for the attribute will not be generated until generate is called. The data pointer must still be valid when SLGLVertexArray::generate is called.

Definition at line 66 of file SLGLVertexArray.cpp.

{
    assert(dataPointer);
    assert(elementSize);
 
    if (type == AT_position && location == -1)
        SL_EXIT_MSG("The position attribute has no variable location.");
 
    if (_vbo.attribIndex(type) >= 0)
        SL_EXIT_MSG("Attribute type already exists.");
 
    SLGLAttribute va;
    va.type            = type;
    va.elementSize     = elementSize;
    va.dataType        = dataType;
    va.dataPointer     = dataPointer;
    va.location        = location;
    va.bufferSizeBytes = 0;
 
    _vbo.attribs().push_back(va);
}

setAttrib() [2/7]

void SLGLVertexArray::setAttrib ( SLGLAttributeType  type, SLint  location, SLVfloat *  data  )

inline

Adds a vertex attribute with vector of SLfloat.

Definition at line 74 of file SLGLVertexArray.h.

                                           { setAttrib(type, 1, location, &data->operator[](0)); }

setAttrib() [3/7]

void SLGLVertexArray::setAttrib ( SLGLAttributeType  type, SLint  location, SLVuint *  data  )

inline

Adds a vertex attribute with vector of SLuint.

Definition at line 69 of file SLGLVertexArray.h.

                                           { setAttrib(type, 1, location, &data->operator[](0), BT_uint); }

setAttrib() [4/7]

void SLGLVertexArray::setAttrib ( SLGLAttributeType  type, SLint  location, SLVVec2f *  data  )

inline

Adds a vertex attribute with vector of SLVec2f.

Definition at line 79 of file SLGLVertexArray.h.

                                           { setAttrib(type, 2, location, &data->operator[](0)); }

setAttrib() [5/7]

void SLGLVertexArray::setAttrib ( SLGLAttributeType  type, SLint  location, SLVVec3f *  data  )

inline

Adds a vertex attribute with vector of SLVec3f.

Definition at line 84 of file SLGLVertexArray.h.

                                           { setAttrib(type, 3, location, &data->operator[](0)); }

setAttrib() [6/7]

void SLGLVertexArray::setAttrib ( SLGLAttributeType  type, SLint  location, SLVVec4f *  data  )

inline

Adds a vertex attribute with vector of SLVec4f.

Definition at line 89 of file SLGLVertexArray.h.

                                           { setAttrib(type, 4, location, &data->operator[](0)); }

setAttrib() [7/7]

void SLGLVertexArray::setAttrib ( SLGLAttributeType  type, SLint  location, SLVVec4i *  data  )

inline

Adds a vertex attribute with vector of SLVec4i.

Definition at line 94 of file SLGLVertexArray.h.

                                           { setAttrib(type, 4, location, &data->operator[](0), BT_int); }

setIndices() [1/4]

void SLGLVertexArray::setIndices	(	SLuint	numIndicesElements,
		SLGLBufferType	indexDataType,
		void *	indexDataElements,
		SLuint	numIndicesEdges = 0,
		void *	indexDataEdges = nullptr
	)

Adds the index array for indexed element drawing.

Defines the vertex indices for the element drawing. Without indices vertex array can only be drawn with SLGLVertexArray::drawArrayAs. Be aware that the VBO for the indices will not be generated until generate is called. The data pointer must still be valid when generate is called.

Definition at line 108 of file SLGLVertexArray.cpp.

{
    assert(numIndicesElements);
    assert(indexDataElements);
 
    if (indexDataType == BT_ushort && _numVertices > 65535)
        SL_EXIT_MSG("Index data type not sufficient.");
    if (indexDataType == BT_ubyte && _numVertices > 255)
        SL_EXIT_MSG("Index data type not sufficient.");
 
    _numIndicesElements = numIndicesElements;
    _indexDataElements  = indexDataElements;
    _indexDataType      = indexDataType;
    _numIndicesEdges    = numIndicesEdges;
    _indexDataEdges     = indexDataEdges;
}

setIndices() [2/4]

void SLGLVertexArray::setIndices ( SLVubyte *  indicesElements, SLVubyte *  indicesEdges = nullptr  )

inline

Adds the index array for indexed element drawing with a vector of ubyte.

Definition at line 106 of file SLGLVertexArray.h.

    {
        setIndices((SLuint)indicesElements->size(),
                   BT_ubyte,
                   (void*)&indicesElements->operator[](0),
                   indicesEdges ? (SLuint)indicesEdges->size() : 0,
                   indicesEdges && indicesEdges->size() ? (void*)&indicesEdges->operator[](0) : nullptr);
    };

setIndices() [3/4]

void SLGLVertexArray::setIndices ( SLVuint *  indicesElements, SLVuint *  indicesEdges = nullptr  )

inline

Adds the index array for indexed element drawing with a vector of uint.

Definition at line 128 of file SLGLVertexArray.h.

    {
        setIndices((SLuint)indicesElements->size(),
                   BT_uint,
                   (void*)&indicesElements->operator[](0),
                   indicesEdges ? (SLuint)indicesEdges->size() : 0,
                   indicesEdges && indicesEdges->size() ? (void*)&indicesEdges->operator[](0) : nullptr);
    }

setIndices() [4/4]

void SLGLVertexArray::setIndices ( SLVushort *  indicesElements, SLVushort *  indicesEdges = nullptr  )

inline

Adds the index array for indexed element drawing with a vector of ushort.

Definition at line 117 of file SLGLVertexArray.h.

    {
        setIndices((SLuint)indicesElements->size(),
                   BT_ushort,
                   (void*)&indicesElements->operator[](0),
                   indicesEdges ? (SLuint)indicesEdges->size() : 0,
                   indicesEdges && indicesEdges->size() ? (void*)&indicesEdges->operator[](0) : nullptr);
    };

setInstanceVBO()

void SLGLVertexArray::setInstanceVBO	(	SLGLVertexBuffer *	vbo,
		SLuint	divisor = 0
	)

Attach a VBO that has been created outside of this VAO.

Assignment of the additional VBO for instanced drawing. The passed vbo contains the positions for the instanced drawing done in drawElementsInstanced. This used e.g. for SLParticleSystems on systems without geometry shaders.

Definition at line 97 of file SLGLVertexArray.cpp.

{
    _instanceVbo     = vbo;
    _instanceDivisor = divisor;
}

tfoID()

SLuint SLGLVertexArray::tfoID ( ) const

inline

Returns the TFO id.

Definition at line 59 of file SLGLVertexArray.h.

{ return _tfoID; }

updateAttrib() [1/6]

void SLGLVertexArray::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 133 of file SLGLVertexArray.cpp.

{
    assert(dataPointer && "No data pointer passed");
    assert(elementSize > 0 && elementSize < 5 && "Element size invalid");
 
    // Get attribute index and check element size
    SLint indexf = _vbo.attribIndex(type);
    if (indexf == -1)
        SL_EXIT_MSG("Attribute type does not exist in VAO.");
 
    if (!_vaoID)
        glGenVertexArrays(1, &_vaoID);
    glBindVertexArray(_vaoID);
 
    // update the appropriate VBO
    if (indexf > -1)
        _vbo.updateAttrib(type, elementSize, dataPointer);
 
    glBindVertexArray(0);
    GET_GL_ERROR;
}

updateAttrib() [2/6]

void SLGLVertexArray::updateAttrib ( SLGLAttributeType  type, SLVfloat *  data  )

inline

Updates a specific vertex attribute in the VBO.

Definition at line 151 of file SLGLVertexArray.h.

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

updateAttrib() [3/6]

void SLGLVertexArray::updateAttrib ( SLGLAttributeType  type, SLVuint *  data  )

inline

Updates a specific vertex attribute in the VBO.

Definition at line 147 of file SLGLVertexArray.h.

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

updateAttrib() [4/6]

void SLGLVertexArray::updateAttrib ( SLGLAttributeType  type, SLVVec2f *  data  )

inline

Updates a specific vertex attribute in the VBO.

Definition at line 155 of file SLGLVertexArray.h.

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

updateAttrib() [5/6]

void SLGLVertexArray::updateAttrib ( SLGLAttributeType  type, SLVVec3f *  data  )

inline

Updates a specific vertex attribute in the VBO.

Definition at line 159 of file SLGLVertexArray.h.

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

updateAttrib() [6/6]

void SLGLVertexArray::updateAttrib ( SLGLAttributeType  type, SLVVec4f *  data  )

inline

Updates a specific vertex attribute in the VBO.

Definition at line 163 of file SLGLVertexArray.h.

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

vaoID()

SLuint SLGLVertexArray::vaoID ( ) const

inline

Returns either the VAO id or the VBO id.

Definition at line 56 of file SLGLVertexArray.h.

{ return _vaoID; }

vbo()

SLGLVertexBuffer* SLGLVertexArray::vbo ( )

inline

Definition at line 207 of file SLGLVertexArray.h.

{ return &_vbo; }

Member Data Documentation

_idVBOIndices

SLuint SLGLVertexArray::_idVBOIndices

protected

Vertex buffer object for float attributes.

Definition at line 219 of file SLGLVertexArray.h.

_indexDataEdges

void* SLGLVertexArray::_indexDataEdges

protected

NO. of vertex indices in array for hard edges.

Definition at line 223 of file SLGLVertexArray.h.

_indexDataElements

void* SLGLVertexArray::_indexDataElements

protected

NO. of vertex indices in array for triangles, lines or points.

Definition at line 221 of file SLGLVertexArray.h.

_indexDataType

SLGLBufferType SLGLVertexArray::_indexDataType

protected

Pointer to index data for hard edges.

Definition at line 224 of file SLGLVertexArray.h.

_instanceDivisor

SLuint SLGLVertexArray::_instanceDivisor

protected

Vertex buffer object containing the positions for instanced drawing.

Definition at line 226 of file SLGLVertexArray.h.

_instances

SLuint SLGLVertexArray::_instances

protected

static total no. of primitives rendered

Definition at line 214 of file SLGLVertexArray.h.

_instanceVbo

SLGLVertexBuffer* SLGLVertexArray::_instanceVbo

protected

index data type (ubyte, ushort, uint)

Definition at line 225 of file SLGLVertexArray.h.

_numIndicesEdges

size_t SLGLVertexArray::_numIndicesEdges

protected

Pointer to index data for elements.

Definition at line 222 of file SLGLVertexArray.h.

_numIndicesElements

size_t SLGLVertexArray::_numIndicesElements

protected

OpenGL id of index vbo.

Definition at line 220 of file SLGLVertexArray.h.

_numVertices

SLuint SLGLVertexArray::_numVertices

protected

OpenGL id of transform feedback object.

Definition at line 217 of file SLGLVertexArray.h.

_tfoID

SLuint SLGLVertexArray::_tfoID

protected

OpenGL id of vertex array object.

Definition at line 216 of file SLGLVertexArray.h.

_vaoID

SLuint SLGLVertexArray::_vaoID

protected

Number of instances of drawing.

Definition at line 215 of file SLGLVertexArray.h.

_vbo

SLGLVertexBuffer SLGLVertexArray::_vbo

protected

NO. of vertices in array.

Definition at line 218 of file SLGLVertexArray.h.

totalDrawCalls

SLuint SLGLVertexArray::totalDrawCalls = 0

static

Definition at line 210 of file SLGLVertexArray.h.

totalPrimitivesRendered

SLuint SLGLVertexArray::totalPrimitivesRendered = 0

static

static total no. of draw calls

Definition at line 211 of file SLGLVertexArray.h.

---

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

• SLGLVertexArray.h
• SLGLVertexArray.cpp