gls_geometry_resource.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsGeometryResource class.
 
  \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_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
#    ifdef __APPLE__
#        include <OpenGL/gl.h>
#    else
#        include <GL/gl.h>
#    endif
#endif
 
#include "disti_assert.h"
#include "gls_matrix_affine.h"
#include "gls_render_effect.h"
#include "gls_resource_file_mgr.h"
#include "vertex.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.
 
    static const unsigned int VERTEX_ATTRIBUTE_SIZE = 3 * sizeof( float );         ///< Size of vertex storage, in bytes.
    static const unsigned int NORMAL_ATTRIBUTE_SIZE = 3 * sizeof( float );         ///< Size of normal storage, in bytes.
    static const unsigned int COLOR_ATTRIBUTE_SIZE  = 4 * sizeof( unsigned char ); ///< Size of color storage, in bytes.
 
    static const unsigned int SECONDARY_COLOR_ATTRIBUTE_SIZE    = 3 * sizeof( unsigned char ); ///< Size of secondary color storage, in bytes.
    static const unsigned int TEXTURE_COORDINATE_ATTRIBUTE_SIZE = 2 * sizeof( float );         ///< Size of texture coordinate storage, in bytes.
    static const unsigned int TANGENT_ATTRIBUTE_SIZE            = 3 * sizeof( float );         ///< Size of tangent storage, in bytes.
    static const unsigned int BINORMAL_ATTRIBUTE_SIZE           = 3 * sizeof( float );         ///< Size of binormal storage, in bytes.
 
    /// \details The TypeDesc class. Describes the underlying format of a GL vertex.
    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
        }
 
        /// Set whether or not there should be storage for normals.
        /// \param value The new normal storage flag.
        void HasNormal( bool value ) { hasNormal = value; }
 
        /// \return Whether or not this type stores normals.
        bool HasNormal() const { return hasNormal; }
 
#ifdef GLES
        void NormalType( unsigned int value )
        {
            normalType = value;
        }
 
        unsigned int NormalType() const { return normalType; }
 
        void         TexCoordType( unsigned int value ) { texCoordType = value; }
        unsigned int TexCoordType() const { return texCoordType; }
#endif
 
        /// Set whether or not there should be storage for colors.
        /// \param value The new color storage flag.
        void HasColor( bool value ) { hasColor = value; }
 
        /// \return Whether or not this type stores colors.
        bool HasColor() const { return hasColor; }
 
        /// Set whether or not there should be storage for secondary colors.
        /// \param value The new secondary color storage flag.
        void HasSecondaryColor( bool value ) { hasSecondaryColor = value; }
 
        /// \return Whether or not this type store secondary colors.
        bool HasSecondaryColor() const { return hasSecondaryColor; }
 
        /// Set the number of texture coordinates to be stored.
        /// \param value The new number of texture coordinates to store.
        void SetNumTextureCoords( unsigned char value )
        {
            if( value <= GlsGeometryResource::MAX_TEXTURE_COORDS )
            {
                numTextureCoords = value;
            }
        }
 
        /// \return The number of texture coordinates stored.
        unsigned char GetNumTextureCoords() const { return numTextureCoords; }
 
        /// Set a component of a texture coordinate.
        /// \param which 0 or 1
        /// \param value 0 through 4
        void SetTexCoordDimension( unsigned char which, unsigned char value )
        {
            if( which < GlsGeometryResource::MAX_TEXTURE_COORDS && value > 0 && value < 5 )
            {
                texCoordDimension[ which ] = value;
            }
        }
 
        /// \return The component of a given texture coordinate (0 through 4).
        /// \param which 0 or 1
        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;
        }
 
        /// \return The number of vertex attributes.
        unsigned char GetNumVertexAttribs() const { return numVertexAttribs; }
 
        /// Set the size (number of components) in the generic vertex attribute.
        /// See documentation on glVertexAttribPointer for details.
        /// \param which The index of the attribute to set.
        /// \param value The value to set at the attribute.
        void SetVertexAttribComponents( unsigned char which, GLint value )
        {
            if( which < GlsGeometryResource::MAX_VERTEX_ATTRIBS && value > 0 && value < 5 )
                vertexAttribNumComponents[ which ] = value;
        }
 
        /// \return The number of components of the given vertex attribute.
        /// \param which The attribute in question.
        GLint GetVertexAttribComponents( unsigned char which ) const { return vertexAttribNumComponents[ which ]; }
 
        /// Set the type of a given generic vertex attribute.
        /// See documentation on glVertexAttribPointer for details.
        /// \param which The index of the attribute to set.
        /// \param value The value to set at the attribute.
        void SetVertexAttribType( unsigned char which, GLenum value )
        {
            if( which < GlsGeometryResource::MAX_VERTEX_ATTRIBS )
            {
                vertexAttribType[ which ] = value;
            }
        }
 
        /// \return The given vertex attribute.
        /// \param which The index of the attribute.
        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.
        /// \param which The index of the attribute to set.
        /// \param value The value to set at the attribute.
        void SetVertexAttribNormalize( unsigned char which, GLboolean value )
        {
            if( which < GlsGeometryResource::MAX_VERTEX_ATTRIBS )
            {
                vertexAttribNormalize[ which ] = value;
            }
        }
 
        /// \return The normalize flag for the given attribute.
        /// \param which The index of the attribute.
        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;
        }
 
        /// \return The semantic value for the given attribute index.
        /// \param which The index of the attribute.
        int GetVertexAttribSemantic( unsigned char which ) const { return vertexAttribSemantic[ which ]; }
    };
 
    /// Something that we can initialize the Resource ID to
    /// and then check for to see if we have initialized the resource.
    typedef enum
    {
        BAD_ID = 0xffffffff
    } BadId;
 
    virtual ~GlsGeometryResource() {}
 
    /// \details The observer class is used for notifications when attributes that affect how the object would draw are changed
    class Observer
    {
    public:
        /// Callback method to be called by this observer.
        virtual void OnGeometryResourceChanged() = 0;
 
    protected:
        Observer() {}
        virtual ~Observer() {}
 
    private:
        // Disable copying
        Observer( const Observer& ) DISTI_SPECIAL_MEM_FUN_DELETE;
        void operator=( const Observer& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    };
 
    /// Adds a new observer to the list.
    /// \param observer The new observer to add.
    void AddObserver( Observer* observer )
    {
        _observers.PushBack( observer );
    }
 
    /// Removes the specified observer from the list.
    /// \param observer The observer to remove.
    void RemoveObserver( Observer* observer )
    {
        _observers.Erase( observer );
    }
 
protected:
    DynamicArray<Observer*> _observers; ///< The held list of observers w/ callbacks.
 
    /// Called to call all observer callbacks when the attribute changes.
    void OnGeometryResourceChanged()
    {
        for( unsigned int i = 0; i < _observers.Count(); ++i )
        {
            _observers[ i ]->OnGeometryResourceChanged();
        }
    }
 
    /** 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;
 
    Vector _boundingVolumeCenter; ///< Center location of the bounding volume.
    float  _boundingVolumeRadius; ///< Radius of the bounding volume.
 
    // Shared between all instances
    static bool _enableVBO; ///< If true, OpenGL supports vertex buffer objects (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.
    /// \param value Whether or not to use half floats.
    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.
    /// \return A pointer to a new GlsGeometryResource.
    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 A pointer to a ResourceRef containing geometry data.
    /// \return A pointer to a new GlsGeometryResource.
    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;
 
    /// \return The vertex count for use in editor statistics.
    /// \param bufferNumber The index of the buffer to count up.
    virtual unsigned int StatsIndexBufferVertexCount( unsigned int bufferNumber ) = 0;
 
    /// \return The polygon count for use in editor statistics.
    /// \param bufferNumber The index of the buffer to count up.
    virtual unsigned int StatsIndexBufferPolygonCount( unsigned int bufferNumber ) = 0;
 
    /// \return 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()
    {
        GLS_ASSERT( _referenceCount > 0 );
 
        _referenceCount--;
 
        if( _referenceCount == 0 )
        {
            Destroy();
        }
    }
 
    /// \returns The number of index buffers in this geometry resource.
    unsigned int NumIndexBuffers() const
    {
        return _numIndexBuffers;
    }
 
    /// \return The bounding sphere center.
    const Vector& BoundingVolumeCenter() const { return _boundingVolumeCenter; }
 
    /// \return 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;
    }
 
    /// \return The current resource ID.
    /// \pre _resourceID != BAD_ID
    GLSGEN_GlsGeometryResource_EXPORT unsigned int GetResourceId()
    {
        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
    //
    ////////////////////////////////
 
    virtual GLSGEN_GlsGeometryResource_EXPORT unsigned int StatsIndexBufferVertexCount( unsigned int bufferNumber ) DISTI_METHOD_OVERRIDE
    {
        return GetIndexBufferSize( bufferNumber ) / 3;
    }
 
    virtual GLSGEN_GlsGeometryResource_EXPORT unsigned int StatsIndexBufferPolygonCount( unsigned int bufferNumber ) DISTI_METHOD_OVERRIDE
    {
        return GetIndexBufferSize( bufferNumber );
    }
 
    virtual GLSGEN_GlsGeometryResource_EXPORT unsigned int GetDataChangedCounter() const DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsGeometryResource_EXPORT void         GetExtents( Vector& min, Vector& max, const GlsMatrixType* matrix = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsGeometryResource_EXPORT void         UpdateBoundingVolume() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsGeometryResource_EXPORT bool         BoundingVolumeHit( const Vector& point, const Vector& direction ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsGeometryResource_EXPORT bool         HitTest( unsigned char pickType, const Vector& pickLinePoint, const Vector& pickLineDirection, Vector& collisionPoint ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsGeometryResource_EXPORT void         DrawSetup( VertexAttribIndexLookup* shaderProgram ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsGeometryResource_EXPORT void         DrawIndexBuffer( unsigned int bufferNumber ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsGeometryResource_EXPORT void         DrawCleanup( VertexAttribIndexLookup* shaderProgram ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsGeometryResource_EXPORT void         FreeOpenGLBuffers() DISTI_METHOD_OVERRIDE;
 
    ////////////////////////////////
    //
    // GlsGeometry_Generic methods
    //
    ////////////////////////////////
 
    /// Create GlsGeometry_Generic from TypeDesc.
    /// \param type The storage format type to use.
    /// \return The new geometry object.
    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
    /// \return The new geometry object.
    static GLSGEN_GlsGeometryResource_EXPORT GlsGeometry_Generic* CreateInstance( GlsResourceFileMgr::ResourceRef* resource );
 
    /// Create GlsGeometry_Generic from binary resource.
    /// \param data The data to create object from.
    /// \return The new geometry object.
    static GLSGEN_GlsGeometryResource_EXPORT GlsGeometry_Generic* CreateFromBinaryResource( GlsResourceFileMgr::BinaryResource* data );
 
    /// Create an empty GlsGeometry_Generic with default TypeDesc.
    /// \return The new geometry object.
    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 );
 
    /// Vector version of SetVertex().
    /// \param vertIndex The index of the vertex to change, 0 to VertexCount() - 1.
    /// \param value The Vector to set, uses its internal float array.
    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 );
 
    /// Two float version of SetTextureCoord().
    /// \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.
    /// \param textureCoordU The new U coordinate to set.
    /// \param textureCoordV The new V coordinate to set.
    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 );
 
    /// One float version of StoreVertexAttrib().
    /// \param vertIndex The index of the vertex.
    /// \param attribIndex The index of the generic vertex attribute to be modified.
    /// \param v A pointer to an array of floats.
    void SetVertexAttrib1fv( GLuint vertIndex, GLuint attribIndex, const GLfloat* v ) { StoreVertexAttrib( vertIndex, attribIndex, (void*)v, 1 * sizeof( float ) ); }
 
    /// Two float version of StoreVertexAttrib().
    /// \param vertIndex The index of the vertex.
    /// \param attribIndex The index of the generic vertex attribute to be modified.
    /// \param v A pointer to an array of floats.
    void SetVertexAttrib2fv( GLuint vertIndex, GLuint attribIndex, const GLfloat* v ) { StoreVertexAttrib( vertIndex, attribIndex, (void*)v, 2 * sizeof( float ) ); }
 
    /// Three float version of StoreVertexAttrib().
    /// \param vertIndex The index of the vertex.
    /// \param attribIndex The index of the generic vertex attribute to be modified.
    /// \param v A pointer to an array of floats.
    void SetVertexAttrib3fv( GLuint vertIndex, GLuint attribIndex, const GLfloat* v ) { StoreVertexAttrib( vertIndex, attribIndex, (void*)v, 3 * sizeof( float ) ); }
 
    /// Four float version of StoreVertexAttrib().
    /// \param vertIndex The index of the vertex.
    /// \param attribIndex The index of the generic vertex attribute to be modified.
    /// \param v A pointer to an array of floats.
    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.
    /// \return A pointer to raw data.
    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.
    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 The matrix used to convert vertex attributes.
    /// \param vertexOffset Start of the range of verts to transform.
    /// \param vertexCount Number of verts to transform.
    /// \return The number of verts that were transformed.
    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.
    /// \param geom The vertices to generate from.
    /// \return Whether or not the generation was successful.
    static GLSGEN_GlsGeometryResource_EXPORT bool GenerateTangentsAndBinormals( GlsGeometry_Generic* geom );
 
    /// \details The VertexStructureDefinition struct. Contains stride and attribute information associated with a vertex buffer object.
    typedef struct
    {
        unsigned int _size; ///< Total size of each vertex in bytes (depends on which data is included).
 
        unsigned int _normalStride;                             ///< Offset between each normal in bytes.
        unsigned int _texcoordStride;                           ///< Offset between each texture coordinate in bytes.
        unsigned int _texcoord2Stride;                          ///< Offset between each secondary texture coordinate in bytes.
        unsigned int _colorStride;                              ///< Offset between each color in bytes.
        unsigned int _secondaryColorStride;                     ///< Offset between each secondary color in bytes.
        unsigned int _numVertexAttribs;                         ///< The count of vertex attributes.
        unsigned int _vertexAttribStride[ MAX_VERTEX_ATTRIBS ]; ///< A list of offsets in bytes for each vertex attribute.
        unsigned int _vertexAttribSize[ MAX_VERTEX_ATTRIBS ];   ///< The size of each vertex attribute in bytes.
    } VertexStructureDefinition;
 
    /// Return the appropriate VertexStructureDefinition type derived from the incoming TypeDesc.
    /// \param vertStruct The returned vertex structure.
    /// \param type The type to generate a vertex structure definiton for.
    static GLSGEN_GlsGeometryResource_EXPORT void SetVertexStructureFromTypeDesc( VertexStructureDefinition& vertStruct, const TypeDesc& type );
 
protected:
    bool _bufferLock; ///< Flag indicating that the vertex buffer is being written to.
 
    char*        _vertexBuffer;        ///< Underlying storage for vertices.
    unsigned int _vertexBufferCount;   ///< The number of vertices in the buffer.
    GLuint       _vertexBufferID;      ///< The OpenGL index for this vertex buffer object.
    bool         _vertexBufferUpdated; ///< Is the video card vertex buffer up to date?
 
    /** Index buffers array */
    GlsGeometry_Generic_IndexBufferData* _indexBuffers;
 
    VertexStructureDefinition _structure; ///< Describes the internal storage pattern for vertices, i.e. does it have colors? textures? normals?
 
    /// Copies vertex data from this buffer into the incoming geometry object.
    /// \param rhs The object to copy vertex data into.
    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 );
 
    /// Shared initialization code used by all constructors.
    void InitializeMembers();
 
    /// Initialize this object from the incoming binary resource.
    /// \param resource The binary resource to initialize with.
    void InitFromBinaryResource( GlsResourceFileMgr::BinaryResource* resource );
 
    /// \return The offset in bytes for the given texture index.
    /// \param whichTexture The texture index to locate.
    unsigned int GetTexcoordByteOffset( unsigned int whichTexture );
 
    GLSGEN_GlsGeometryResource_EXPORT void Destroy() DISTI_METHOD_OVERRIDE;
 
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 );
};
 
} // namespace disti
 
#endif