gls_geometry_resource.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsGeometryResource class.

  \par Copyright Information

  Copyright (c) 2015 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_GEOMETRY_RESOURCE_H_INCLUDED
#define GLS_GEOMETRY_RESOURCE_H_INCLUDED

#include "assert.h"

#ifdef _WIN32
    #include <windows.h>
#endif

#ifdef LINUX
    #include <limits.h>
#endif

#ifdef GLES
    #include "gls_gl.h"
    #include "limits.h"
#else
    #include <GL/gl.h>
#endif

#include "vertex.h"
#include "gls_matrix_affine.h"
#include "disti_assert.h"
#include "gls_resource_file_mgr.h"
#include "gls_render_effect.h"

//////////////////// Provides support for creating DLLs ////////////////////////
#if (defined(GLSGEN_EXPORT_GLSGEOMETRYRESOURCE) || \
     defined(GLSGEN_IMPORT_GLSGEOMETRYRESOURCE) || \
     defined(GLS_EXPORT_GENERATED) || \
     defined(GLS_IMPORT_GENERATED)) \
     && defined(_MSC_VER)
#  if defined(GLSGEN_EXPORT_GLSGEOMETRYRESOURCE) || defined(GLS_EXPORT_GENERATED)
#    define GLSGEN_GlsGeometryResource_EXPORT    __declspec(dllexport)
#  else
#    define GLSGEN_GlsGeometryResource_EXPORT    __declspec(dllimport)
#  endif
#else
#  define GLSGEN_GlsGeometryResource_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////

namespace disti
{

/** The geometry resource abstract base class */
class GlsGeometryResource
{
public:

    static const unsigned int MAX_TEXTURE_COORDS = 2; // GL_MAX_TEXTURE_COORDS. GlsGeometryResource currently only supports two sets of texture coordinates
    static const unsigned int MAX_VERTEX_ATTRIBS = 16; // GL_MAX_VERTEX_ATTRIBS

    /** The sizes of various vertex attributes, in bytes. */
    static const unsigned int VERTEX_ATTRIBUTE_SIZE = 3 * sizeof(float);
    static const unsigned int NORMAL_ATTRIBUTE_SIZE = 3 * sizeof(float);
#ifdef GLES
    static const unsigned int COLOR_ATTRIBUTE_SIZE = 4 * sizeof(unsigned char);
#else
    static const unsigned int COLOR_ATTRIBUTE_SIZE = sizeof(unsigned int);
#endif
    static const unsigned int SECONDARY_COLOR_ATTRIBUTE_SIZE = 3 * sizeof(unsigned char);
    static const unsigned int TEXTURE_COORDINATE_ATTRIBUTE_SIZE = 2 * sizeof(float);
    static const unsigned int TANGENT_ATTRIBUTE_SIZE = 3 * sizeof(float);
    static const unsigned int BINORMAL_ATTRIBUTE_SIZE = 3 * sizeof(float);

    class TypeDesc
    {
        bool hasNormal; // True if vertices have normals (float[3])
        bool hasColor; // True if vertices have color (UINT32)
        bool hasSecondaryColor; // True if vertices have secondary color (UINT32)
#ifdef GLES
        unsigned int  normalType; // GL_FLOAT or GL_UNSIGNED_BYTE
        unsigned int  texCoordType; // GL_FLOAT or GL_SHORT
#endif

        unsigned char numTextureCoords; // Number of texture coordinates per vertex [0-MAX_TEXTURE_COORDS]
        unsigned char texCoordDimension[GlsGeometryResource::MAX_TEXTURE_COORDS]; // Number of components for each texture coordinate
        unsigned char numVertexAttribs; // Number of generic vertex attributes per vertex [0-MAX_VERTEX_ATTRIBS]
        GLint vertexAttribNumComponents[GlsGeometryResource::MAX_VERTEX_ATTRIBS]; // Number of components in the generic vertex attribute
        GLenum vertexAttribType[GlsGeometryResource::MAX_VERTEX_ATTRIBS]; // Specifies the type of each vertex attribute
        GLboolean vertexAttribNormalize[GlsGeometryResource::MAX_VERTEX_ATTRIBS]; // Specifies whether fixed-point data values should be normalized (GL_TRUE) or converted directly as fixed-point values (GL_FALSE) when they are accessed.
        unsigned int vertexAttribSemantic[GlsGeometryResource::MAX_VERTEX_ATTRIBS]; // Semantic for each vertex attribute
  public:

        // Default constructor
        TypeDesc()
        {
            memset(this, 0, sizeof(TypeDesc));
            unsigned int i;
            for(i = 0; i < GlsGeometryResource::MAX_TEXTURE_COORDS; i++)
            {  texCoordDimension[i] = 2;  }
            for(i = 0; i < GlsGeometryResource::MAX_VERTEX_ATTRIBS; i++)
            { vertexAttribNumComponents[i] = 4; }
#ifdef GLES
            normalType = GL_FLOAT;
            texCoordType = GL_FLOAT;
#endif
        }

        void HasNormal(bool value) { hasNormal = value; }
        bool HasNormal(void) const { return hasNormal; }

#ifdef GLES
        void NormalType(unsigned int value) { normalType = value; }

        unsigned int NormalType(void) const { return normalType; }

        void TexCoordType(unsigned int value) { texCoordType = value; }
        unsigned int TexCoordType(void) const { return texCoordType; }  
#endif

        void HasColor(bool value) { hasColor = value; }
        bool HasColor(void) const { return hasColor; }

        void HasSecondaryColor(bool value) { hasSecondaryColor = value; }
        bool HasSecondaryColor(void) const { return hasSecondaryColor; }

        void SetNumTextureCoords(unsigned char value)
        {
            if (value <= GlsGeometryResource::MAX_TEXTURE_COORDS)
                numTextureCoords = value;
        }
        unsigned char GetNumTextureCoords(void) const { return numTextureCoords; }

        void SetTexCoordDimension(unsigned char which, unsigned char value)
        {
            if (which < GlsGeometryResource::MAX_TEXTURE_COORDS &&
                value > 0 && value < 5)
                texCoordDimension[which] = value;
        }
        unsigned char GetTexCoordDimension(unsigned char which) const { return texCoordDimension[which]; }

        /** Set the number of generic vertex attributes stored in the resource.
            Generic vertex attributes are passed to OpenGL using glVertexAttribPointer.
            These are special attributes to be used by the vertex shader.

            \param value The new number of generic vertex attributes
            \sa SetVertexAttribSizeBytes
         */
        void SetNumVertexAttribs(unsigned char value)
        {
            if (value <= GlsGeometryResource::MAX_VERTEX_ATTRIBS)
                numVertexAttribs = value;
        }
        unsigned char GetNumVertexAttribs(void) const { return numVertexAttribs; }

        /// Set the size (number of components) in the generic vertex attribute
        /// See documentation on glVertexAttribPointer for details
        void SetVertexAttribComponents(unsigned char which, GLint value)
        {
            if (which < GlsGeometryResource::MAX_VERTEX_ATTRIBS &&
                value > 0 && value < 5)
                vertexAttribNumComponents[which] = value;
        }
        GLint GetVertexAttribComponents(unsigned char which) const { return vertexAttribNumComponents[which]; }

        /// Set the type of a given generic vertex attribute
        /// See documentation on glVertexAttribPointer for details
        void SetVertexAttribType(unsigned char which, GLenum value)
        {
            if (which < GlsGeometryResource::MAX_VERTEX_ATTRIBS)
                vertexAttribType[which] = value;
        }
        GLenum GetVertexAttribType(unsigned char which) const { return vertexAttribType[which]; }

        /// Set whether fixed-point data values should be normalized
        /// (Default is false)
        /// See documentation on glVertexAttribPointer for details
        void SetVertexAttribNormalize(unsigned char which, GLboolean value)
        {
            if (which < GlsGeometryResource::MAX_VERTEX_ATTRIBS)
                vertexAttribNormalize[which] = value;
        }
        GLboolean GetVertexAttribNormalize(unsigned char which) const { return vertexAttribNormalize[which]; }

        /// Set semantic of a given generic vertex attribute
        /// The semantic value can be used to determine the "meaning" of the vertex attribute
        /// \param which Which vertex attrib to set
        /// \param semanticEnum The new sematic value (see AttributeSemanticEnum)
        void SetVertexAttribSemantic(unsigned char which, int semanticEnum)
        {
            if (which < GlsGeometryResource::MAX_VERTEX_ATTRIBS)
                vertexAttribSemantic[which] = semanticEnum;
        }
        int GetVertexAttribSemantic(unsigned char which) const { return vertexAttribSemantic[which]; }

    };

    typedef enum
    {
        // Something that we can initialize the Resource ID to
        // and then check for to see if we have initialized
        // the resource.
        BAD_ID  = 0xffffffff
    } BadId;

    virtual ~GlsGeometryResource() {}

protected:
    /** Give this Resource a unique id so we can get it. */
    unsigned int _resourceID;

    /** The number of Parent Objects using this object. Once the number reaches zero, the object self deletes. */
    unsigned int _referenceCount;

    /** The TypeDesc that describes what is in this Resource */
    TypeDesc _type;

    /** The number of index buffers in this mesh */
    unsigned int _numIndexBuffers;

    // Bounding volume information
    Vector _boundingVolumeCenter;
    float _boundingVolumeRadius;

    // Shared between all instances
    static bool _enableVBO;  // If the OpenGL Context is version 1.5 or greater

    /** Deletes this object from the heap that it was allocated on */
    virtual void Destroy() = 0;

public:

    /** When enabled, GlsGeometryResource::CreateInstance will instantiate GlsGeometry_HalfFloat objects when possible. */
    static GLSGEN_GlsGeometryResource_EXPORT void SetCreateInstanceMakesHalfFloat(bool value);

    /** Construct an empty GlsGeometryResource with the given type
        The initial reference count is 1.
        Call DecrementReference to free the resource when you are done with it.
        \param type A description of the initial Structure
    */
    static GLSGEN_GlsGeometryResource_EXPORT GlsGeometryResource* CreateInstance(const TypeDesc& type = GlsGeometryResource::TypeDesc());

    /** Construct a GlsGeometryResource from a binary resource
        The initial reference count is 1.
        Call DecrementReference to free the GlsGeometryResource when you are done with it.
        \param resource pointer to a ResourceRef containing geometry data
     */
    static GLSGEN_GlsGeometryResource_EXPORT GlsGeometryResource* CreateInstance(GlsResourceFileMgr::ResourceRef* resource);

    /** Setup the OpenGL state for rendering this geometry.
        To draw, call DrawIndexBuffer for each index buffer in the resource.
        After drawing, call DrawCleanup to restore the OpenGL state.
        \param shaderProgram interface to the shader program, used to lookup correct VertexAttrib index values (may be NULL)
        \post The OpenGL state is configured for rendering from the index buffers.
    */
    virtual void DrawSetup(VertexAttribIndexLookup* shaderProgram) = 0;

    /** Draw the geometry specified by the given index buffer
        This method should only be called between calls to DrawSetup
        and DrawCleanup.
        \pre DrawSetup has been called.
        \param bufferNumber Which index buffer to draw
    */
    virtual void DrawIndexBuffer(unsigned int bufferNumber) = 0;

    /** Restore the OpenGL state after rendering.
        \param shaderProgram Must be the same value that was passed to DrawSetup
        \pre DrawSetup was called
        \post The OpenGL state will be restored
    */
    virtual void DrawCleanup(VertexAttribIndexLookup* shaderProgram) = 0;

    /** Force the GlsGeometryResource to free any buffers it has allocated in the current OpenGL context.
    */
    virtual void FreeOpenGLBuffers() = 0;

    /** Since calculating metrics like the extents can be an expensive operation, the user can call this 
      * function to see if the geometry resource has changed. Caching the expensive-to-calculate values 
      * is the responsibility of the caller.
      * \return The current extents ID. Never equal to s_invalidDataChangedCounter.
      * \sa s_invalidDataChangedCounter
      */
    virtual unsigned int GetDataChangedCounter() const = 0;

    /** A sentinel value for clients to initialize their counts with. GetDataChangedCounter() will never return this value. */
    static const unsigned int s_invalidDataChangedCounter = 0;

    /** Calculate and return the geometry extents
      * \param min Returns the minimum x,y,z values
      * \param max Returns the maximum x,y,z values
      * \param matrix (Optional) matrix to transform the vertices into the desired coordinate system
      * \note This can be an expensive operation. GetDataChangedCounter() can be used to minimize this expense.
      * \sa GetDataChangedCounter()
      */
    virtual void GetExtents(Vector& min, Vector& max, const GlsMatrixType* matrix = NULL ) = 0;

    /** Updates the bounding volume of this object
      * This method should be called if the vertices change for picking and
      * culling to work correctly.
      * \note This can be an expensive operation. GetDataChangedCounter() can be used to minimize this expense.
      * \sa GetDataChangedCounter()
      */
    virtual void UpdateBoundingVolume() = 0;

    /** Determines if the given ray hits the geometry bounding volume.
      * Note: All parameters should be in this object's coordinates.
      * @param point The starting point of the ray.
      * @param direction The direction vector of the ray.
      * @return  True if this bounding volume is hit by the ray.
      */
    virtual bool BoundingVolumeHit(const Vector& point, const Vector& direction) = 0;

    /** Hit test the geometry against a picking line. All values are in geometry space.
     * \param pickType The type of picking (see PickableType_e), must be PICK_FIRST or PICK_BEST
     * \param pickLinePoint  A point on the pick line.
     * \param pickLineDirection  The direction of the pick line.
     * \param collisionPoint  If the method returns true, this contains the point that was hit.
     * \return true if the object was hit by the pick.
     */
    virtual bool HitTest(unsigned char pickType, const Vector& pickLinePoint, const Vector& pickLineDirection, Vector& collisionPoint) = 0;


    /** Returns vertex count for use in editor statistics */
    virtual unsigned int StatsIndexBufferVertexCount(unsigned int bufferNumber) = 0;

    /** Returns polygon count for use in editor statistics */
    virtual unsigned int StatsIndexBufferPolygonCount(unsigned int bufferNumber) = 0;



    /** Returns the TypeDesc for this resource */
    GLSGEN_GlsGeometryResource_EXPORT const TypeDesc& Type() { return _type; }

    /** Increment the Reference count to this instance. */
    GLSGEN_GlsGeometryResource_EXPORT void IncrementReference() { _referenceCount++; }

    /** Decrement the Reference count to this instance.
      * \note The OpenGL context should be available to free resources.
      */
    GLSGEN_GlsGeometryResource_EXPORT void DecrementReference()
    {
        DistiAssert(_referenceCount > 0);

        _referenceCount--;

        if (_referenceCount == 0)
        {
            Destroy();
        }
    }

    /** Returns The number of index buffers in this geometry resource. */
    unsigned int NumIndexBuffers() const
    {
        return _numIndexBuffers;
    }

    /** Get the bounding sphere center */
    const Vector& BoundingVolumeCenter() const { return _boundingVolumeCenter; }

    /** Get the bounding sphere radius */
    float BoundingVolumeRadius() const { return _boundingVolumeRadius; }

    /** Sets a new resource ID
      * \param id The new ID
      * \pre id != BAD_ID
      */
    GLSGEN_GlsGeometryResource_EXPORT void SetResourceId(unsigned int id)
    {
        assert(BAD_ID != id);
        _resourceID = id;
    }

    /** Gets the current resource ID
      * \pre _resourceID != BAD_ID
      */
    GLSGEN_GlsGeometryResource_EXPORT unsigned int GetResourceId(void)
    {
        assert(BAD_ID != _resourceID);
        return _resourceID;
    }
};


/** Forward declaration */
class GlsGeometry_Generic_IndexBufferData;
/** Flexible implementation of GlsGeometryResource that can store any type of geometry
  * This resource is used in the editor and may be used at runtime if there is not a more efficient implementation for the desired TypeDesc.
  */
class GlsGeometry_Generic : public GlsGeometryResource
{
public:

    ////////////////////////////////
    //
    // GlsGeometryResource methods
    //
    ////////////////////////////////

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT unsigned int StatsIndexBufferVertexCount(unsigned int bufferNumber)
    {
        return GetIndexBufferSize(bufferNumber) / 3;
    }

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT unsigned int StatsIndexBufferPolygonCount(unsigned int bufferNumber)
    {
        return GetIndexBufferSize(bufferNumber);
    }

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT unsigned int GetDataChangedCounter() const;

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT void GetExtents(Vector& min, Vector& max, const GlsMatrixType* matrix = NULL);

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT void UpdateBoundingVolume(void);

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT bool BoundingVolumeHit(const Vector& point, const Vector& direction);

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT bool HitTest(unsigned char pickType, const Vector& pickLinePoint, const Vector& pickLineDirection, Vector& collisionPoint);

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT void DrawSetup(VertexAttribIndexLookup* shaderProgram);

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT void DrawIndexBuffer(unsigned int bufferNumber);

    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT void DrawCleanup(VertexAttribIndexLookup* shaderProgram);


    // See base class
    virtual GLSGEN_GlsGeometryResource_EXPORT void FreeOpenGLBuffers();



    ////////////////////////////////
    //
    // GlsGeometry_Generic methods
    //
    ////////////////////////////////

    /** Create GlsGeometry_Generic from TypeDesc */
    static GLSGEN_GlsGeometryResource_EXPORT GlsGeometry_Generic* CreateInstance(const TypeDesc& type);

    /** Construct a GlsGeometryResource from a binary resource
        The initial reference count is 1.
        Call DecrementReference to free the GlsGeometryResource when you are done with it.
        \param resource pointer to a ResourceRef containing geometry data
     */
    static GLSGEN_GlsGeometryResource_EXPORT GlsGeometry_Generic* CreateInstance(GlsResourceFileMgr::ResourceRef* resource);

    /** Create GlsGeometry_Generic from binary resource */
    static GLSGEN_GlsGeometryResource_EXPORT GlsGeometry_Generic* CreateFromBinaryResource( GlsResourceFileMgr::BinaryResource* data );

    /** Create an empty GlsGeometry_Generic with default TypeDesc */
    static GLSGEN_GlsGeometryResource_EXPORT GlsGeometry_Generic* CreateEmptyInstance();

    /** Copy the geometry from another resource into this one.
        Does not change the Type of this resource: only vertex attributes that both resources have in common will be copied.
        \param rhs the resource to copy from
    */
    GLSGEN_GlsGeometryResource_EXPORT void CopyVertexAndIndexBuffers(GlsGeometry_Generic* rhs);

    /** Changes the Type of this geometry resource.
        This is a slow operation; it creates new storage according to the typeDesc and copys the existing vertex data.
        If a vertex attribute does not map to the new type it will be lost.  Any new attributes will be uninitialized.
        Requires that the OpenGL context is current if this GlsGeometryResource has been previously drawn.

        \param type The TypeDesc to use for the new structure
    */
    GLSGEN_GlsGeometryResource_EXPORT void ChangeType(const TypeDesc& type);

    /** Attempt to Lock the Buffers, Non-Blocking
        \return True if a lock is posible
    */
    GLSGEN_GlsGeometryResource_EXPORT bool LockBuffers();

    /** Release the lock on the buffers.
        Note: If the Vertex data was changed, you should typically call UpdateBoundingVolume() before unlocking.
        \see UpdateBoundingVolume
        \post If the buffer is not locked a debug message is sent to the terminal
    */
    GLSGEN_GlsGeometryResource_EXPORT void UnlockBuffers();

    /** Get the size of the vertex buffer
        \return The number of items in the vertex buffer
    */
    GLSGEN_GlsGeometryResource_EXPORT unsigned int VertexCount() const;

    /** Set the size of the vertex buffer
        \param count How many items the Vertex Buffer contains.
        \pre size must be greater than zero
    */
    GLSGEN_GlsGeometryResource_EXPORT void VertexCount(unsigned int count);

    /** Set a vertex
        \param vertIndex The index of the vertex to change, 0 to VertexCount() - 1
        \param *value Vertex can either be 3 or 4 floats depending on the type
        \pre vertex must be a pointer to 3 or 4 floats, vertIndex must be less than VertexCount()
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetVertex(GLuint vertIndex, const float *value);

    void SetVertex(GLuint vertIndex, const Vector *value) { SetVertex(vertIndex, (float*)value); }

    /** Initialize the vertex data from an array of floats.

        Steps through the array reading the data for each vertex.  If Type() is POSITION_XYZ, the method will read 3 floats per vertex.
        If Type() is POSITION_XYZW, the method will read 4 floats per vertex.

        \param floatArray Pointer to the array to read from.  The array must be at least (numVertices * stride) bytes.
        \param numVertices Number of vertices to read from of the array
        \param startVertIndex (optional) The vertex buffer index to start copying into
        \param stride (optional) The distance between each vertex in the floatArray (in bytes)
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetVertices(const float *floatArray,
                                                       unsigned int numVertices,
                                                       unsigned int startVertIndex = 0,
                                                       unsigned int stride = VERTEX_ATTRIBUTE_SIZE);

    /** Set the vertex at a given index to a coordinate
        \param vertIndex The index of the vertex to change, 0 to VertexCount() - 1
        \param x The x-coord
        \param y The y-coord
        \param z The z-coord
        \pre vertex must be a pointer to 3 or 4 floats, vertIndex must be less than VertexCount()
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetVertex(GLuint vertIndex,
                                                     float x,
                                                     float y,
                                                     float z);

    /** Return a pointer to an array of 3 or 4 floats which is the vertex
        for the given index.

        \param vertIndex The index of the vertex to get, 0 to VertexCount() - 1
        \return a pointer to a 3 or 4 float vertex
        \pre vertIndex must be less than VertexCount()
    */
    GLSGEN_GlsGeometryResource_EXPORT const float* GetVertex(GLuint vertIndex);

    /** Set a Normal
        \param vertIndex The index of the vertex to change, 0 to VertexCount() - 1
        \param x X Normal value to assign
        \param y Y Normal value to assign
        \param z Z Normal value to assign
        \pre normal must be a valid Vector, vertIndex must be less than VertexCount()
             NORMAL must be part of the Type
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetNormal(GLuint vertIndex, float x, float y, float z);

    /** Initialize the vertex normals from an array of floats.

        Steps through the array reading the normal data for each vertex.  The method will read 3 floats for each normal.

        \param floatArray Pointer to the array to read from. The array must be at least (numVertices * stride) bytes.
        \param numVertices Number of vertices to read from of the array
        \param startVertIndex (optional) The vertex buffer index to start copying into
        \param stride (optional) The distance between each normal in the floatArray (in bytes)
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetNormals(const float *floatArray,
                                                      unsigned int numVertices,
                                                      unsigned int startVertIndex = 0,
                                                      unsigned int stride = NORMAL_ATTRIBUTE_SIZE);

    /** Get a pointer to the Normal for a given Vertex index.  Do
        not change the Normal, change it through the Set function!
        \param vertIndex The index of the Normal to get, 0 to VertexCount() - 1
        \return a pointer to an array of 3 floats.
        \pre vertIndex must be less than VertexCount()
             NORMAL must be part of the Type
    */
    GLSGEN_GlsGeometryResource_EXPORT const float * GetNormal(GLuint vertIndex);

    /** Set a color value
        \param vertIndex The index of the color value to change, 0 to VertexCount() - 1
        \param red Red
        \param green Green
        \param blue  Blue
        \param alpha Alpha
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetColor(GLuint vertIndex,
                                                    unsigned char red,
                                                    unsigned char green,
                                                    unsigned char blue,
                                                    unsigned char alpha);

    /** Initialize the vertex colors from an array of unsigned int containing rgba color data.

        Steps through the array reading the color data for each vertex.  The method will read 1 integer for each color.

        \param rgbaArray pointer to the array to read from. The array must be at least (numVertices * stride) bytes.
        \param numVertices Number of vertices to read from of the array
        \param startVertIndex (optional) The vertex buffer index to start copying into
        \param stride (optional) The distance between each color in the rgbaArray (in bytes)
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetColors(const unsigned int *rgbaArray,
                                                     unsigned int numVertices,
                                                     unsigned int startVertIndex = 0,
                                                     unsigned int stride = COLOR_ATTRIBUTE_SIZE);

    /** Initialize Color from an array
        \param array an array of color values in RGBA order of size VertexCount()
        \pre The array must be of size VertexCount()
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetColors(const unsigned int *array);

    /** Gets the color value of the given vertex index
        \param vertIndex The index of the color value to get, 0 to VertexCount() - 1
        \return a pointer to a color array in rgba order
        \pre vertIndex must be less than VertexCount(),
    */
    GLSGEN_GlsGeometryResource_EXPORT unsigned char * GetColor(GLuint vertIndex);

    /** Set a secondary color value (specular)
        \param red Red
        \param green Green
        \param blue  Blue
        \param vertIndex The index of the secondary color value to change, 0 to VertexCount() - 1
        \pre vertIndex must be less than VertexCount()
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetSecondaryColor(GLuint vertIndex,
                                                          unsigned char red,
                                                          unsigned char green,
                                                          unsigned char blue);

    /** Initialize the vertex secondary colors from an array of unsigned int containing rgb color data. (Secondary colors do not include alpha)

        Steps through the array reading the color data for each vertex.  The method will read 3 bytes for each color.

        \param rgbArray pointer to the array to read from. The array must be at least (numVertices * stride) bytes.
        \param numVertices Number of vertices to read from of the array
        \param startVertIndex (optional) The vertex buffer index to start copying into
        \param stride (optional) The distance between each color in the array (in bytes)
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetSecondaryColors(const unsigned int *rgbArray,
                                                              unsigned int numVertices,
                                                              unsigned int startVertIndex = 0,
                                                              unsigned int stride = SECONDARY_COLOR_ATTRIBUTE_SIZE);

    /** Get the secondary color of the vertex at the given index.
        \param vertIndex The index of the secondary color value to get, 0 to VertexCount() - 1
        \return a pointer to a secondary color value in RGB order
        \pre vertIndex must be less than VertexCount()
    */
    GLSGEN_GlsGeometryResource_EXPORT unsigned char * GetSecondaryColor(GLuint vertIndex);


    /** Set a TextureCoord
        \param textureCoord TextureCoord value to assign.  Must point to a float array containing TextureCoordinateDepth() elements
        \param vertIndex The index of the TextureCoord value to change, 0 to VertexCount() - 1
        \param whichTexture Which set of texture coordinates to change, 0 to NumTextureCoordinateArrays() - 1.
        \pre    vertIndex must be less than VertexCount()
                TEXCOORD must be part of the Type
                whichTexture must be 0 to 7
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetTextureCoord(GLuint vertIndex, unsigned int whichTexture,
                                                           const float *textureCoord);

    GLSGEN_GlsGeometryResource_EXPORT void SetTextureCoord(GLuint vertIndex, unsigned int whichTexture,
                                                           float textureCoordU,
                                                           float textureCoordV);

#ifdef GLES
    /** Sets all texture coordinates from a pointer of texture coordinate data

      \param whichTexture Which set of texture coordinates to change, 0 to NumTextureCoordinateArrays() - 1.
      \param textureCoordArray Pointer to texture coordinate data to assign.  Must point to a float array containing TextureCoordinateDepth() elements
      \param numVertices The number of vertices worth of texture coordinate data in the array
      \param startIndex (optional) The texture coord vertex element to start copying into
      \param stride (optional) The distance between each texture coordinate in the array (in bytes)
     */
    GLSGEN_GlsGeometryResource_EXPORT void SetTextureCoords(unsigned int whichTexture,
                                                            const float *textureCoordArray,
                                                            unsigned int numVertices,
                                                            unsigned int startVertIndex = 0,
                                                            unsigned int stride = TEXTURE_COORDINATE_ATTRIBUTE_SIZE);
#endif

    /** Get a TextureCoord
        \param vertIndex The index of the TextureCoord value to change, 0 to VertexCount() - 1
        \param whichTexture Which set of texture coordinates to change, 0 to NumTextureCoordinateArrays() - 1.
        \return Return a pointer to the Texture Coordinates ask for
        \pre    vertIndex must be less than VertexCount()
                TEXCOORD must be part of the Type
                textureCount must be 1 to 8
    */
    GLSGEN_GlsGeometryResource_EXPORT const float * GetTextureCoord(GLuint vertIndex, unsigned int whichTexture);


    /** Store a generic vertex attribute value
        \param vertIndex The index of the vertex
        \param attribIndex The index of the generic vertex attribute to be modified
        \param value void pointer to the value
        \param sizeBytes size of the value in bytes
     */
    GLSGEN_GlsGeometryResource_EXPORT void StoreVertexAttrib(GLuint vertIndex, GLuint attribIndex, void* value, GLuint sizeBytes);

    void SetVertexAttrib1fv(GLuint vertIndex, GLuint attribIndex, const GLfloat *v) { StoreVertexAttrib(vertIndex, attribIndex, (void*)v, 1*sizeof(float)); }
    void SetVertexAttrib2fv(GLuint vertIndex, GLuint attribIndex, const GLfloat *v) { StoreVertexAttrib(vertIndex, attribIndex, (void*)v, 2*sizeof(float)); }
    void SetVertexAttrib3fv(GLuint vertIndex, GLuint attribIndex, const GLfloat *v) { StoreVertexAttrib(vertIndex, attribIndex, (void*)v, 3*sizeof(float)); }
    void SetVertexAttrib4fv(GLuint vertIndex, GLuint attribIndex, const GLfloat *v) { StoreVertexAttrib(vertIndex, attribIndex, (void*)v, 4*sizeof(float)); }

#ifdef GLES
    GLSGEN_GlsGeometryResource_EXPORT void SetVertexAttribs(const float* attribArray,

        GLuint attribIndex,
        unsigned int numVertices,
        unsigned int startVertIndex = 0,
        unsigned int stride = TANGENT_ATTRIBUTE_SIZE);
#endif

    /** Get pointer to the raw vertex attribute data
        Be careful with this!
        \note This method may be removed in the future
        \param vertIndex The index of the vertex
        \param attribIndex The index of the generic vertex attribute
     */
    GLSGEN_GlsGeometryResource_EXPORT void* GetVertexAttrib(GLuint vertIndex, GLuint attribIndex);

    using GlsGeometryResource::NumIndexBuffers;

    /** Get the number of available index buffers
      * \param count Set the number of index buffers in this geometry resource.
      */
    GLSGEN_GlsGeometryResource_EXPORT void NumIndexBuffers(unsigned int count);

    /** Gets the size of an index buffer
        \param bufferNum Which index buffer to return the size of
        \return The number of items that the given index buffer can hold
    */
    GLSGEN_GlsGeometryResource_EXPORT unsigned int GetIndexBufferSize(unsigned int bufferNum) const;

    /** Set the size of the specified index buffer
        \param bufferNum Which index buffer to set the size of
        \param newSize How many items the Index Buffer can hold.
        \pre newSize must be greater than zero
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetIndexBufferSize(unsigned int bufferNum, unsigned int newSize);

    /** Change the Vertex index
        \param bufferNum Which index buffer to modify
        \param index The index of the Index to change, 0 to GetIndexBufferSize(bufferNum)) - 1
        \param indexValue Index must be less than GetIndexBufferSize(bufferNum)
    */
    GLSGEN_GlsGeometryResource_EXPORT void SetIndex(unsigned int bufferNum, unsigned int index, unsigned int indexValue);

#ifndef GLES

    /** Initialize the Index buffer from an array of index values
      *
      * Steps through the array reading the color data for each vertex.  The method will read 3 bytes for each color.
      *
      * \param bufferNum Which index buffer to modify
      * \param indexArray pointer to the array to read from. The array must be at least (numIndices * stride) bytes.
      * \param numIndices Number of indices to read from of the array
      * \param startIndex (optional) The index buffer element to start copying into
      * \param stride (optional) The distance between each index in the array (in bytes)
      */
    GLSGEN_GlsGeometryResource_EXPORT void SetIndices(unsigned int bufferNum,
                                                      const unsigned int *indexArray,
                                                      unsigned int numIndices,
                                                      unsigned int startIndex = 0,
                                                      unsigned int stride = sizeof(unsigned int));

    /** Gets an index from an index buffer
        \param bufferNum Which index buffer to read from
        \param index The index of the Index to get, 0 to GetIndexBufferSize(bufferNum) - 1
        \return an Index value
        \pre index must be less than GetIndexBufferSize(bufferNum)
    */
    GLSGEN_GlsGeometryResource_EXPORT unsigned int GetIndex(unsigned int bufferNum, unsigned int index);

    /** Merge two index buffers by adding the indexes from the source buffer to the dest buffer,
        then deleting the source buffer.
        \param dstBufferNum Which index buffer to add to
        \param srcBufferNum Which index buffer to delete
        \returns true on success, false if there was an error
    */
    GLSGEN_GlsGeometryResource_EXPORT void MergeIndexBuffers(unsigned int dstBufferNum, unsigned int srcBufferNum);

#else // GLES

    /** Initialize the Index buffer from an array of index values

     Steps through the array reading the color data for each vertex.  The method will read 3 bytes for each color.

     \param bufferNum Which index buffer to modify
     \param indexArray pointer to the array to read from. The array must be at least (numIndices * stride) bytes.
     \param numIndices Number of indices to read from of the array
     \param startIndex (optional) The index buffer element to start copying into
     \param stride (optional) The distance between each index in the array (in bytes)
     */
    GLSGEN_GlsGeometryResource_EXPORT void SetIndices(unsigned int bufferNum,
                                                      const unsigned int *indexArray,
                                                      unsigned int numIndices,
                                                      unsigned int startIndex = 0,
                                                      unsigned int stride = sizeof(unsigned int));

    /** Get an index from an index buffer
        \param bufferNum Which index buffer to read from
        \param index The index of the Index to get, 0 to GetIndexBufferSize(bufferNum) - 1
        \return an Index value
        \pre index must be less than GetIndexBufferSize(bufferNum)
    */
    GLSGEN_GlsGeometryResource_EXPORT unsigned short GetIndex(unsigned int bufferNum, unsigned short index);

#endif // !GLES

   /** See GlsGeometryResource::VertexSort() */
    typedef struct
    {
        unsigned int _order;           // The order the vertex should be in
        unsigned int _vertexTupleIndex;// The index of the primitive
    } VertexSortData;

    /** Sort the vertices, based on the input data

        \param *sortData An array of VertexSortData structures, one for each primitive (set of three vertices).
                The data in this is array is used to reorder the primitives. e.g.:
                Input:
                  order 0,1,0,5,2
                  index 0,1,2,3,4
                Sorted:
                  order 0,0,1,2,5
                  index 0,2,1,4,3

        \pre sortData must be an array of VertexSortData VertexCount()/3 in size

        \post The sortData array will be sorted based on _order.
              The vertex buffer will be sorted based on the new order from the sortData.
    */
    GLSGEN_GlsGeometryResource_EXPORT void VertexSort(VertexSortData* sortData);

    /** Dump all the vertices to the terminal
    */
    GLSGEN_GlsGeometryResource_EXPORT void DumpVertices();

    /** Dump all the Normals to the terminal
    */
    GLSGEN_GlsGeometryResource_EXPORT void DumpNormals();

    /** Dump all the Indices to the terminal
    */
    GLSGEN_GlsGeometryResource_EXPORT void DumpIndices();

    /** Copy vertex attributes from srcGeom to dstGeom
        Does not change the Type of the resource: only vertex attributes that both resources have in common will be copied.
        \param dstGeom the resource to copy to
        \param dstOffset vertex offset to start copying at
        \param srcGeom the resource to copy from
        \param srcOffset vertex offset to start copying from
        \param vertexCount number of vertices to copy
        \returns the number of vertices that were copied
    */
    static GLSGEN_GlsGeometryResource_EXPORT unsigned int CopyVertexData(
        GlsGeometry_Generic* dstGeom, unsigned int dstOffset,
        GlsGeometry_Generic* srcGeom, unsigned int srcOffset,
        unsigned int vertexCount);

    /* Apply a transform to the vertex attributes of the given mesh
     * The transform affects vertex position, normals, ATTRIB_TANGENT, and ATTRIB_BINORMAL
     * \param dstGeom The resource to modify
     * \param transform matrix used to convert vertex attributes
     * \param vertexOffset start of the range of verts to transform
     * \param vertexCount number of verts to transform
     */
    static GLSGEN_GlsGeometryResource_EXPORT unsigned int TransformVertexData(
        GlsGeometry_Generic* dstGeom,
        GlsMatrixType* transform,
        unsigned int vertexOffset = 0,
        unsigned int vertexCount = UINT_MAX);

    // Generate tangents/binormals for all vertices in the given
    // GlsGeometryResource and adds them as vertex attributes.
    static GLSGEN_GlsGeometryResource_EXPORT bool GenerateTangentsAndBinormals(GlsGeometry_Generic* geom);

    typedef struct
    {
        unsigned int _size;    // Total size of each vertex (depends on which data are included)

        /** Offsets into the structure for the various data
        */
        unsigned int _normalStride;
        unsigned int _texcoordStride;
        unsigned int _texcoord2Stride;
        unsigned int _colorStride;
        unsigned int _secondaryColorStride;
        unsigned int _numVertexAttribs;
        unsigned int _vertexAttribStride[MAX_VERTEX_ATTRIBS];
        unsigned int _vertexAttribSize[MAX_VERTEX_ATTRIBS];
    } VertexStructureDefinition;

    static GLSGEN_GlsGeometryResource_EXPORT void SetVertexStructureFromTypeDesc( VertexStructureDefinition& vertStruct, const TypeDesc& type );


protected:

    bool _bufferLock;

    char *_vertexBuffer;
    unsigned int _vertexBufferCount;
    GLuint _vertexBufferID;
    bool _vertexBufferUpdated; // Is the video card vertex buffer up to date?

    /** Index buffers array */
    GlsGeometry_Generic_IndexBufferData *_indexBuffers;
    //unsigned int _numIndexBuffers; // in base class for inlining

    VertexStructureDefinition _structure;

    GLSGEN_GlsGeometryResource_EXPORT void CopyVertexBufferOnly(GlsGeometry_Generic* rhs);

    /** Utility routine used by Hit.  Performs a "BestHit" test, which performs a hit test on the object
      * and guarantees that the collision point returned by Hit is the closest collision point to the observer.
      * @param point            The geometry coordinate of the click, relative to the object
      * @param directionVector  The direction of the pick vector
      * @param collisionPoint   Set to the point on the object hit by directionVector
      * @return booleanean indicating if the object was hit by the mouse
      */
    GLSGEN_GlsGeometryResource_EXPORT bool BestHit(const Vector &point,const Vector& directionVector,Vector& collisionPoint);

    /**  Utility routine used by Hit.  Performs a "FirstHit" test, which performs a hit test on the object
    *    but does not guarantee that the collision point returned by Hit is the closest collision point
    *    to the observer
    * @param point            The logical coordinate of the click, relative to the object
    * @param directionVector  The direction of the pick vector
    * @param collisionPoint   Set to the point on the object hit by directionVector
    * @return boolean indicating if the object was hit
    */
    GLSGEN_GlsGeometryResource_EXPORT bool FirstHit(const Vector &point,const Vector& directionVector,Vector& collisionPoint);

    void InitializeMembers();

    void InitFromBinaryResource( GlsResourceFileMgr::BinaryResource* resource );

    unsigned int GetTexcoordByteOffset( unsigned int whichTexture );

    GLSGEN_GlsGeometryResource_EXPORT void Destroy();

private:

    // Member data
    unsigned int _dataChangedCounter;

    /** Should be called when any data changes. Used to optimize calls like GetExtents(). */
    void IncDataChangedCounter() 
    { 
        // If we hit the invalid ID, skip past it.
        if( ++_dataChangedCounter == s_invalidDataChangedCounter )
        {
            ++_dataChangedCounter;
        }
    }

    /** Private Constructor: Use CreateInstance methods */
    GLSGEN_GlsGeometryResource_EXPORT GlsGeometry_Generic();

    /** Private Destructor: Use DecrementReference to delete the object*/
    GLSGEN_GlsGeometryResource_EXPORT ~GlsGeometry_Generic();

    // Disable implicit generated Members
    GlsGeometry_Generic( const GlsGeometry_Generic &src );
    GlsGeometry_Generic& operator=( const GlsGeometry_Generic &rhs );
};

}

#endif