gls_vertex_array.h

Go to the documentation of this file.

 
/*! \file
 \brief  An object for managing vertices, texture coordinates, colors and normals for GLPolygon and other display objects
         Used for porting DisplayObjects which use immediate mode drawing to use VBOs
 
 \par Copyright Information
 
 Copyright (c) 2017 by The DiSTI Corporation.<br>
 11301 Corporate Blvd., Suite 100<br>
 Orlando, Florida 32817<br>
 USA<br>
 <br>
 All rights reserved.<br>
 
 This Software contains proprietary trade secrets of DiSTI and may not be
 reproduced, in whole or part, in any form, or by any means of electronic,
 mechanical, or otherwise, without the written permission of DiSTI.  Said
 permission may be derived through the purchase of applicable DiSTI product
 licenses which detail the distribution rights of this content and any
 Derivative Works based on this or other copyrighted DiSTI Software.
 
 NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
 AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
 PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
 AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
 PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
 LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
 IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
 INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
 DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
 INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
 INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
 OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
 EXCEED FIVE DOLLARS (US$5.00).
 
 The aforementioned terms and restrictions are governed by the laws of the
 State of Florida and the United States of America.
 
 */
#ifndef GLS_VERTEX_ARRAY_H
#define GLS_VERTEX_ARRAY_H
 
#include "dynamic_array.h"
#include "gls_color.h"
#include "gls_gl.h"
#include "gls_include.h"
#include "gls_index_array.h"
#include "image.h"
#include "non_copyable.h"
#include "vertex.h"
 
namespace disti
{
class GlsStateManager;
 
/// \details The GlsVertexArray class. This holds a number of Vertex objects in a resizeable buffer.
class GlsVertexArray : public NonCopyable
{
public:
    static const GLuint VERT_SIZE   = sizeof( GL_FLOAT ) * 3;         ///< Size of a vertex in bytes.
    static const GLuint TEX_SIZE    = sizeof( GL_FLOAT ) * 2;         ///< Size of a texture coordinate in bytes.
    static const GLuint NORMAL_SIZE = sizeof( GL_FLOAT ) * 3;         ///< Size of a normal in bytes.
    static const GLuint COLOR_SIZE  = sizeof( GL_UNSIGNED_BYTE ) * 4; ///< Size of a color in bytes.
 
    /** Default constructor
     */
    GlsVertexArray();
 
    /** Destructor
     */
    virtual ~GlsVertexArray();
 
    /** Prepare the vertex buffer to be populated.  Allocates vertex buffer, sets up component offsets.
     * \param nVerts  Number of vertices in the array
     * \param hasT    True if array has texture coords
     * \param hasC    True if array has colors
     * \param hasN    True if array has normas
     */
    void Setup( const int nVerts, const bool hasT, const bool hasC, const bool hasN );
 
    /** Sets the vertices of the array
     * \pre  _setup == true
     * \param verts  An array of vertices to populate this object with.  verts[] must have at least _nVerts elements
     */
    void SetVertices( const Vertex verts[] );
 
    /** Sets the texture coordinates of the array
     * \pre  (_setup && _hasT)
     * \param verts  An array of texture coords to populate this object with.  verts[] must have at least _nVerts elements
     */
    void SetTexCoords( const Vector verts[] );
 
    /** Sets the Normals of the array
     * \pre  (_setup && _hasN)
     * \param verts  An array of normals to populate this object with.  verts[] must have at least _nVerts elements
     */
    void SetNormals( const Vector verts[] );
 
    /** Sets the Colors of the array.  Note:  This takes an array of Vertex for compatibility with DisplayObject.
     *  It gets the colors from the color component of the vertices.
     * \pre  (_setup && _hasC)
     * \param verts  An array of colors to populate this object with.  verts[] must have at least _nVerts elements
     */
    void SetColors( const Vertex verts[] );
 
    /** Sets a single vertex
     * \pre  _setup && (index < _nVerts)
     * \param index  The index of the vertex to set
     * \param v      The vertex to set
     */
    void SetVertex( const unsigned int index, const Vector& v );
 
    /** Sets a single texture coordinate
     * \pre  _setup && (index < _nVerts) && _hasT
     * \param index  The index of the texture coordinate to set
     * \param v      The texture coordinate to set
     */
    void SetTexCoord( const unsigned int index, const Vector& v );
 
    /** Bake the vertex buffer to a VBO
     * \pre _setup == true
     * \param stateManager  State manager for the OpenGL context to bake the VBO in
     */
    void Bake( IGlsStateManager* stateManager );
 
    /** Draw this vertex array
     * \pre  _setup == true
     * \post The VBO is drawn
     * \param glPrimitive   The OpenGL primitive type to draw (e.g. GL_LINE_LOOP)
     * \param stateManager  State manager for the OpenGL context to draw in
     * \param texture       Whether or not to draw with texture
     * \param color         Whether or not to use per vertex colors
     * \param normal        Whether or not to use per vertex normals
     */
    void Draw( const unsigned int glPrimitive, IGlsStateManager* stateManager, const bool texture, const bool color, const bool normal );
 
    /** Draw this vertex array
     * \pre  _setup == true
     * \post The VBO is drawn
     * \param glPrimitive   The OpenGL primitive type to draw (e.g. GL_LINE_LOOP)
     * \param offset        Index of the first vertex to draw
     * \param count         Number of primitives to draw
     * \param indexBuffer   Index buffer to use
     * \param stateManager  State manager for the OpenGL context to draw in
     * \param texture       Whether or not to draw with texture
     * \param color         Whether or not to use per vertex colors
     * \param normal        Whether or not to use per vertex normals
     */
    void Draw( const unsigned int glPrimitive, const unsigned int offset, const unsigned int count, GlsIndexArray& indexBuffer, IGlsStateManager* stateManager,
        const bool texture, const bool color, const bool normal );
 
    /** Draw this vertex array
     * \pre  _setup == true
     * \post The VBO is drawn
     * \param glPrimitive   The OpenGL primitive type to draw (e.g. GL_LINE_LOOP)
     * \param offset        Index of the first vertex to draw
     * \param count         Number of primitives to draw
     * \param primitiveSize Number of vertices per primitive
     * \param indexBuffer   Index buffer to use
     * \param stateManager  State manager for the OpenGL context to draw in
     * \param texture       Whether or not to draw with texture
     * \param color         Whether or not to use per vertex colors
     * \param normal        Whether or not to use per vertex normals
     */
    void MultiDraw( const unsigned int glPrimitive, const unsigned int offset, const unsigned int count, const unsigned int primitiveSize, GlsIndexArray& indexBuffer, IGlsStateManager* stateManager, const bool texture, const bool color, const bool normal );
 
protected:
    unsigned char* _vertexData; /**< Contains the dynamically allocated, interleaved vertex data that gets sent to the VBO */
 
    unsigned int _vboHandle;  /**< OpenGL VBO handle */
    unsigned int _bufferSize; /**< Size of data pointed to by _vertexData */
    bool         _setup;      /**< True if this object has been setup and can be downloaded to a VBO */
 
    bool _hasT; /**< True if this object has texture coordinates */
    bool _hasN; /**< True if this object has normals */
    bool _hasC; /**< True if this object has colors */
 
    unsigned int _componentSize; /**< Size of one element of this array (total size of all components) in bytes */
    unsigned int _texOffset;     /**< Offset of the texture coords from the beginning of a component, in bytes */
    unsigned int _normalOffset;  /**< Offset of the normals from the beginning of a component, in bytes */
    unsigned int _colorOffset;   /**< Offset of the color from the beginning of a component, in bytes */
    unsigned int _nVerts;        /**< Number of vertices in this object */
 
    /** Allocates the buffer data, copying the existing data
     * \param size The new size in bytes to allocate
     */
    void AllocateBuffer( const unsigned int size );
 
    /** Deallocates the buffer data
     */
    void DeallocateBuffer();
};
 
} // namespace disti
 
#endif