gls_quad_storage.h

Go to the documentation of this file.

/*! \file
  \brief The disti::GlsQuadListVC_3D and GlsQuadListVCT_2D classes.
 
  \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. Use, distribution,
duplication, or disclosure by the U. S. Government is subject to
"Restricted Rights" as set forth in DFARS 252.227-7014(c)(1)(ii).
 
*/
 
#ifndef GLS_QUAD_STORAGE_H
#define GLS_QUAD_STORAGE_H
 
#include "IFontImage.h"
#include "dynamic_array.h"
#include "gls_color.h"
#include "gls_gl.h"
#include "gls_include.h"
#include "gls_primitive_storage_types.h"
#include "gls_state_manager.h"
#include "non_copyable.h"
#include "vertex.h"
 
namespace disti
{
class Image;
 
/**
 * GlsQuadListVC_3D
 */
class GlsQuadListVC_3D : public NonCopyable
{
public:
    static const GLuint VERT_SIZE  = sizeof( Vector );   ///< Size of a vertex in bytes.
    static const GLuint COLOR_SIZE = sizeof( glsColor ); ///< Size of a color in bytes.
 
    /// Constant offsets to the primitive vertex attribute.
    /// \note Theoretically should be GLuint, but OpenGL's functions pass integer offsets as pointers.
    static const void* const VERT_OFFSET;
 
    /// Constant offsets to the color vertex attribute.
    /// \note Theoretically should be GLuint, but OpenGL's functions pass integer offsets as pointers.
    static const void* const COLOR_OFFSET;
 
    /** Default constructor
     */
    GlsQuadListVC_3D();
 
    /** Destructor
     */
    virtual ~GlsQuadListVC_3D();
 
    /** Add a quad defined by a 2D rectangle from x1,y1 to x2,y2
      * \param x1  X coord of point 1
      * \param y1  Y coord of point 1
      * \param x2  X coord of point 2
      * \param y2  Y coord of point 2
      */
    void AddQuad2D( const float x1, const float y1, const float x2, const float y2 );
 
    /** Add a 3D quad defined by 4 3D vertices
     * \param v  Array of 4 vertices containing the vertices of the 3D quad
     */
    void AddQuad3D( const Vector v[] );
 
    /** Set the current drawing color.  When a quad is added, its vertex colors are set to the current color
      * \param color  The color to set
      */
    void SetColor( const glsColor& color );
 
    /** Put the quad list in list building mode.  Process for using this quad list:
      *  1.  Build the list
      *  2.  Bake the list (creates VBOs)
      *  3.  Draw the list
      */
    void StartBuilding();
 
    /** Bakes the quad list, creating VBOs within the GL context.
      * The VBOs created by Bake are used when the object is later drawn with Draw
      * \param stateManager The StateManager object to create the VBOs within
      */
    void Bake( IGlsStateManager* stateManager );
 
    /** Draws this quad list
      * \param stateManager  OpenGL context to draw list in
      * \param enableColor   Whether or not to use the per vertex colors when drawing
      */
    void Draw( IGlsStateManager* stateManager, const bool enableColor );
 
    /** Draws this quad list as a series of line loops
     * \param stateManager  OpenGL context to draw list in
     * \param enableColor   Whether or not to use the per vertex colors when drawing
     */
    void DrawOutlines( IGlsStateManager* stateManager, const bool enableColor );
 
    /** \return Returns the number of quads in the list */
    unsigned int NumQuads()
    {
        return _numQuads;
    }
 
protected:
    unsigned int                 _numQuads; /**< Number of quads in the list */
    DynamicArray<V3f_C4ub, true> _vertData; /**< Vertices for the quad list */
    DynamicArray<GLushort, true> _indices;  /**< Indices for the quad list */
 
    unsigned int _vboHandle;         /**< VBO Handle for this quad storage */
    unsigned int _indexBufferHandle; /**< Index buffer Handle for this quad storage */
    unsigned int _vboBufferSize;     /**< Size of the VBO buffer.  Cached to so that when a quad is cleared and reset
                                            we will only reallocate the VBO when its size changes. */
 
    glsColor _currentColor; /**< Last color that was set.  Used only while building a list */
 
    /// Called by AddQuad methods to internally allocate the next quad.
    void AllocateNextQuad();
 
    /** Bind the quad list's VBOs and prepare for drawing
     * \param stateManager  OpenGL context to draw list in
     * \param enableColor   Whether or not to use the per vertex colors when drawing
     */
    void SetupVBO( IGlsStateManager* stateManager, const bool enableColor );
};
 
/**
 * GlsQuadListVCT_2D
 */
class GlsQuadListVCT_2D : public NonCopyable
{
public:
    static const GLuint VERT_SIZE  = sizeof( V2f );      ///< Size of a vertex in bytes.
    static const GLuint TEX_SIZE   = sizeof( V2f );      ///< Size of a texture coordinate in bytes.
    static const GLuint COLOR_SIZE = sizeof( glsColor ); ///< Size of a color in bytes.
 
    /// Constant offsets to the primitive vertex attribute.
    /// \note Strange casting is to support OpenGL's repurposed functions that pass offsets as pointers.
    static const void* const VERT_OFFSET;
 
    /// Constant offsets to the primitive texture coordinate attribute.
    /// \note Strange casting is to support OpenGL's repurposed functions that pass offsets as pointers.
    static const void* const TEX_COORD_OFFSET;
 
    /// Constant offsets to the primitive color attribute.
    /// \note Strange casting is to support OpenGL's repurposed functions that pass offsets as pointers.
    static const void* const COLOR_OFFSET;
 
    /** Default constructor
     */
    GlsQuadListVCT_2D();
 
    /** Destructor
     */
    virtual ~GlsQuadListVCT_2D();
 
    /** Set the current texture coordinates.  When a quad is added, these texture coordinates will be used.
      * x1,y1 will map to quad vertex[0] and x2,y2 will map to quad vertex[1]
      * \param x1  X coord of point 1
      * \param y1  Y coord of point 1
      * \param x2  X coord of point 2
      * \param y2  Y coord of point 2
      */
    void SetTexCoords( const float x1, const float y1, const float x2, const float y2 );
 
    /** Set the current texture.  This texture will be used when drawing the quad list (if not NULL)
      * \param image The texture to set, NULL for no texture
      */
    void SetTexture( IFontImage* image );
 
    /** Set the current drawing color.  When a quad is added, its vertex colors are set to the current color
     * \param color  The color to set
     */
    void SetColor( const glsColor& color );
 
    /** Put the quad list in list building mode.  Process for using this quad list:
     *  1.  Build the list
     *  2.  Bake the list (creates VBOs)
     *  3.  Draw the list
     */
    void StartBuilding();
 
    /** Bakes the quad list, creating VBOs within the GL context.
     * The VBOs created by Bake are used when the object is later drawn with Draw
     * \param stateManager The StateManager object to create the VBOs within
     */
    void Bake( IGlsStateManager* stateManager );
 
    /** Add a quad defined by a 2D rectangle from x1,y1 to x2,y2
     * \param x1  X coord of point 1
     * \param y1  Y coord of point 1
     * \param x2  X coord of point 2
     * \param y2  Y coord of point 2
     */
    void AddQuad2D( const float x1, const float y1, const float x2, const float y2 );
 
    /** Draws this quad list
     * \param stateManager  OpenGL context to draw list in
     * \param enableColor   Whether or not to use the per vertex colors when drawing
     * \param enableTexture Whether or not to use the texture when drawing
     */
    void Draw( IGlsStateManager* stateManager, const bool enableColor, const bool enableTexture );
 
    /** \return Returns the number of quads in the list */
    unsigned int NumQuads()
    {
        return _numQuads;
    }
 
protected:
    /// \details The TextureGroup class. Holds a number of textured quads.
    class TextureGroup : public NonCopyable
    {
    public:
        /** Default constructor
         */
        TextureGroup();
 
        /** Destructor
         */
        virtual ~TextureGroup();
 
        /** Set the current texture.  This texture will be used when drawing the quad list (if not NULL)
          * \param texture The texture to set, NULL for no texture
          */
        void SetTexture( IFontImage* texture );
 
        /** Get the current texture.  This texture will be used when drawing the quad list (if not NULL)
          * \return The texture to set, NULL for no texture
          */
        IFontImage* GetTexture();
 
        /** Put the quad list in list building mode.  Process for using this quad list:
         *  1.  Build the list
         *  2.  Bake the list (creates VBOs)
         *  3.  Draw the list
         */
        void StartBuilding();
 
        /** Bakes the quad list, creating VBOs within the GL context.
         * The VBOs created by Bake are used when the object is later drawn with Draw
         * \param stateManager The StateManager object to create the VBOs within
         */
        void Bake( IGlsStateManager* stateManager );
 
        /** Add a quad defined by a 2D rectangle from x1,y1 to x2,y2
         * \param x1  X coord of point 1
         * \param y1  Y coord of point 1
         * \param x2  X coord of point 2
         * \param y2  Y coord of point 2
         * \param tex  texture coordinates
         * \param color  color of the quad points
         */
        void AddQuad2D( const float x1, const float y1, const float x2, const float y2,
            const V2f tex[], const glsColor& color );
 
        /** Draws this quad list
         * \param stateManager  OpenGL context to draw list in
         * \param enableColor   Whether or not to use the per vertex colors when drawing
         * \param enableTexture Whether or not to use the texture when drawing
         */
        void Draw( IGlsStateManager* stateManager, const bool enableColor, const bool enableTexture );
 
    protected:
        unsigned int                     _numQuads; /**< Number of quads in the list */
        DynamicArray<V2f_T2f_C4ub, true> _vertData; /**< Vertices for the quad list */
        DynamicArray<GLushort, true>     _indices;  /**< Indices for the quad list */
 
        IFontImage* _texture; /**< Texture to use when drawing quad storage.  NULL if untextured */
 
        unsigned int _vboHandle;         /**< VBO Handle for this quad storage */
        unsigned int _indexBufferHandle; /**< Index buffer Handle for this quad storage */
        unsigned int _vboBufferSize;     /**< Size of the VBO buffer.  Cached to so that when a quad is cleared and reset
                                                we will only reallocate the VBO when its size changes. */
 
        /// Called by AddQuad methods to internally allocate the next quad.
        void AllocateNextQuad();
    };
 
    DynamicArray<TextureGroup*, false> _textureGroups;       ///< The list of all textured quad groups.
    unsigned int                       _numTextureGroups;    ///< The number of textured quad groups in the list.
    TextureGroup*                      _currentTextureGroup; ///< Pointer to the current texture group that quads will be added to with the next call to AddQuad.
 
    unsigned int _numQuads; /**< Number of quads in the list (total) */
 
    V2f _currentTex[ 4 ]; /**< Current texture coordinates supplied for current quad
                             (Texture coordinates are not required to change per quad).
                             Used only while building list. */
 
    glsColor _currentColor; /**< Last color that was set.  Used only while building a list */
};
 
} // namespace disti
 
#endif