gls_nine_patch.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsNinePatch 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_NINE_PATCH_H
#define _GLS_NINE_PATCH_H
#include "glpolygon.h"
#include "gls_cpp_lang_support.h"
 
#ifdef GLES
#    include "gls_index_array.h"
#    include "gls_vertex_array.h"
#else
#    include "gls_display_list.h"
#endif
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSNINEPATCH ) || defined( GLSGEN_IMPORT_GLSNINEPATCH ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSNINEPATCH ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GLSNINEPATCH_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSNINEPATCH_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSNINEPATCH_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_nine_patch"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
// SetValue enumerations
enum
{
    GLS_NINE_PATCH_FIRST_VALUE = GLS_LAST_INITIALIZER + 1,
    GLS_NINE_PATCH_CENTER_VISIBLE,
    GLS_NINE_PATCH_EDGES,
    GLS_NINE_PATCH_TEXTURE_EDGES,
    GLS_NINE_PATCH_RADII,
    GLS_NINE_PATCH_TEXTURE_POINTS,
    GLS_NINE_PATCH_COLOR,
    GLS_NINE_PATCH_REFERENCE_TEXTURE_WIDTH_HEIGHT
};
 
#define GLS_NINE_PATCH_ARRAY_SIZE 16 ///< The number of vertices present in a nine patch.
 
/** Runtime implementation of a GlsNinePatch */
class GlsNinePatch : public GLPolygon
{
    friend class GlsNinePatchEditor;
 
private:
    GlsNinePatch& operator=( const GlsNinePatch& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsNinePatch( const GlsNinePatch& ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef GLPolygon _BaseClass; ///< Deprecated typedef for the base class.
    typedef GLPolygon BaseClass;  ///< Typedef for the base class.
 
    /// \details The Rect3D class. Describes a 3D bounding box.
    class Rect3D
    {
    public:
        Vector blc; ///< The bottom left corner.
        Vector brc; ///< The bottom right corner.
        Vector trc; ///< The top right corner.
 
        Rect3D(){};
    };
 
    /// Constructor
    /// \param generateInstance Whether or not to generate an instance name for this object.
    GLSGEN_GLSNINEPATCH_EXPORT GlsNinePatch( bool generateInstance = false );
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name for this object.
    GLSGEN_GLSNINEPATCH_EXPORT GlsNinePatch( const GlsNinePatch& that, const bool generateNames );
 
    virtual GLSGEN_GLSNINEPATCH_EXPORT ~GlsNinePatch();
 
    /// \return A pointer to a new GlsNinePatch object.
    static GLSGEN_GLSNINEPATCH_EXPORT DisplayObject* CreateInstance();
 
    // DisplayObject overrides
 
    virtual GLSGEN_GLSNINEPATCH_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT Vertex* Vertices() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void    GetExtents( float& minx, float& miny, float& minz, float& maxx, float& maxy, float& maxz ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void    GetTransformedExtents( Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void    UpdateBoundingVolume() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void    SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void    SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void           CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void           CopyGeometry( DisplayObject* srcArg ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GLSNINEPATCH_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSNINEPATCH_EXPORT void Calculate( double time ) DISTI_METHOD_OVERRIDE;
 
#ifdef GLES
    virtual GLSGEN_GLSNINEPATCH_EXPORT void PreDraw( const OpenGLMatrices& current, Culler& culler ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSNINEPATCH_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSNINEPATCH_EXPORT void     SetFillColor( const GlsColor& color ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSNINEPATCH_EXPORT GlsColor GetFillColor() DISTI_METHOD_OVERRIDE;
 
    /** Gets the polygon drawing mode for this object
      * \return The polygon drawing mode for this object
      * \sa PolygonMode_e
      */
    virtual GLSGEN_GLSNINEPATCH_EXPORT int PolygonMode() DISTI_METHOD_OVERRIDE { return POLY_MODE_FILLED; }
 
    /** Sets the polygon drawing mode for this object
      * \param mode The new polygon drawing mode for this object
      * \sa PolygonMode_e
      */
    virtual GLSGEN_GLSNINEPATCH_EXPORT void PolygonMode( int mode ) DISTI_METHOD_OVERRIDE {} // do nothing
 
    /** The enumeration defining which edge textures and vertices refer to*/
    enum Edge
    {
        FIRST  = 0,
        LEFT   = 0,
        RIGHT  = 1,
        TOP    = 2,
        BOTTOM = 3,
        // The number of items
        COUNT = 4
    };
 
    /// Set's the texture edge at enum specified by index to the value specified as pixel units.
    /// \param index Refers to the texture edge enumeration that will be modified.
    /// \param value The pixel unit(s) assigned to the specificed texture edge enumeration.
    GLSGEN_GLSNINEPATCH_EXPORT void TextureEdge( Edge index, float value );
 
    /// Shortcut to set the nine patch's left texture edge.
    /// \param value The new texture edge value in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT void LeftTextureEdge( float value ) { TextureEdge( LEFT, value ); }
 
    /// Shortcut to set the nine patch's right texture edge.
    /// \param value The new texture edge value in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT void RightTextureEdge( float value ) { TextureEdge( RIGHT, value ); }
 
    /// Shortcut to set the nine patch's top texture edge.
    /// \param value The new texture edge value in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT void TopTextureEdge( float value ) { TextureEdge( TOP, value ); }
 
    /// Shortcut to set the nine patch's bottom texture edge.
    /// \param value The new texture edge value in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT void BottomTextureEdge( float value ) { TextureEdge( BOTTOM, value ); }
 
    /// Set's the vertex edge at enum specified by index to the value specified as logical units.
    /// \param index Refers to the vertex edge enumeration that will be modified.
    /// \param value Is the logical unit(s) assigned to the specificed vertex edge enumeration.
    GLSGEN_GLSNINEPATCH_EXPORT void VertexEdge( Edge index, float value );
 
    /// Shortcut to set the nine patch's left vertex edge.
    /// \param value The new vertex edge value in logical units.
    GLSGEN_GLSNINEPATCH_EXPORT void LeftVertexEdge( float value ) { VertexEdge( LEFT, value ); }
 
    /// Shortcut to set the nine patch's right vertex edge.
    /// \param value The new vertex edge value in logical units.
    GLSGEN_GLSNINEPATCH_EXPORT void RightVertexEdge( float value ) { VertexEdge( RIGHT, value ); }
 
    /// Shortcut to set the nine patch's top vertex edge.
    /// \param value The new vertex edge value in logical units.
    GLSGEN_GLSNINEPATCH_EXPORT void TopVertexEdge( float value ) { VertexEdge( TOP, value ); }
 
    /// Shortcut to set the nine patch's bottom vertex edge.
    /// \param value The new vertex edge value in logical units.
    GLSGEN_GLSNINEPATCH_EXPORT void BottomVertexEdge( float value ) { VertexEdge( BOTTOM, value ); }
 
    /// Return the value in pixel units of the TextureEdge given at enumeration specified by index.
    /// \param index Refers to the edge enumeration that the value will be gotten from.
    /// \return A float value in pixel units that corresponds with the respective VertexEdge index/enum.
    virtual GLSGEN_GLSNINEPATCH_EXPORT float TextureEdge( Edge index );
 
    /// \return The left texture edge value in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT float LeftTextureEdge() { return TextureEdge( LEFT ); }
 
    /// \return The right texture edge value in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT float RightTextureEdge() { return TextureEdge( RIGHT ); }
 
    /// \return The top texture edge value in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT float TopTextureEdge() { return TextureEdge( TOP ); }
 
    /// \return The bottom texture edge value in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT float BottomTextureEdge() { return TextureEdge( BOTTOM ); }
 
    /// Return the value in logical units at the edge enumeration specified by index.
    /// \param index Refers to the edge enumeration.
    /// \return A float value in logical units that corresponds with the respective TextureEdge index/enum.
    virtual GLSGEN_GLSNINEPATCH_EXPORT float VertexEdge( Edge index );
 
    /// \return The left vertex edge value in logical units.
    GLSGEN_GLSNINEPATCH_EXPORT float LeftVertexEdge() { return VertexEdge( LEFT ); }
 
    /// \return The right vertex edge value in logical units.
    GLSGEN_GLSNINEPATCH_EXPORT float RightVertexEdge() { return VertexEdge( RIGHT ); }
 
    /// \return The top vertex edge value in logical units.
    GLSGEN_GLSNINEPATCH_EXPORT float TopVertexEdge() { return VertexEdge( TOP ); }
 
    /// \return The bottom vertex edge value in logical units.
    GLSGEN_GLSNINEPATCH_EXPORT float BottomVertexEdge() { return VertexEdge( BOTTOM ); }
 
    /// Getter function to determine whether or not the center will be drawn.
    /// \return True being returned lets the user know that the Center of the NinePatch is visible.
    GLSGEN_GLSNINEPATCH_EXPORT bool CenterVisible() { return _centerVisible; }
 
    /// Set whether or not the center quad will be drawn..
    /// \param value The new visibility flag for the center quad.
    GLSGEN_GLSNINEPATCH_EXPORT void CenterVisible( bool value );
 
    /// Sets the radii of the width vector in logical units.
    /// \param v Will set the radii's width row's logical values of the glsNinePatch object.
    GLSGEN_GLSNINEPATCH_EXPORT void WidthVector( const Vector& v );
 
    /// Sets the radii of the height vector in logical units.
    /// \param v Will set the radii's height row's logical values of the glsNinePatch object.
    GLSGEN_GLSNINEPATCH_EXPORT void HeightVector( const Vector& v );
 
    /// Gets the radii of the width vector in logical units.
    /// \return The width of the NinePatch as a Vector.
    GLSGEN_GLSNINEPATCH_EXPORT const Vector WidthVector() const { return _radii[ 0 ]; }
 
    /// Gets the radii of the height vector in logical units.
    /// \return The height of the NinePatch as a Vector.
    GLSGEN_GLSNINEPATCH_EXPORT const Vector HeightVector() const { return _radii[ 1 ]; }
 
    /// Setter function for the bottom left corner of the texture in the GlsNinePatch.
    /// \param x A pixel unit value that is applied to the GlsNinePatch's first field in the 'Bottom Left Corner' vector.
    /// \param y A pixel unit value that is applied to the GlsNinePatch's second field in the 'Bottom Left Corner' vector.
    GLSGEN_GLSNINEPATCH_EXPORT void TextureBLC( const float x, const float y );
 
    /// Setter function for the bottom left corner of the texture in the GlsNinePatch.
    /// \param value A vector containing x and y pixel unit values to apply to the texture bottom left corner.
    GLSGEN_GLSNINEPATCH_EXPORT void TextureBLC( const Vector& value ) { TextureBLC( value.x, value.y ); }
 
    /// Setter function for the top right corner of the texture in the GlsNinePatch.
    /// \param x A pixel unit value that is applied to the GlsNinePatch's first field in the 'Top Right Corner' vector.
    /// \param y A pixel unit value that is applied to the GlsNinePatch's second field in the 'Top Right Corner' vector.
    GLSGEN_GLSNINEPATCH_EXPORT void TextureTRC( const float x, const float y );
 
    /// Setter function for the top right corner of the texture in the GlsNinePatch.
    /// \param value A vector containing x and y pixel unit values to apply to the texture top right corner.
    GLSGEN_GLSNINEPATCH_EXPORT void TextureTRC( const Vector& value ) { TextureTRC( value.x, value.y ); }
 
    /// Getter function for the bottom left corner of the texture in the GlsNinePatch.
    /// \return The vector in pixel units for the value of the 'Bottom Left Corner'.
    GLSGEN_GLSNINEPATCH_EXPORT Vector TextureBLC() const { return _textureBLC; }
 
    /// Getter function for the top right corner of the texture in the GLSNinePatch.
    /// \return The vector in pixel units for the value of the 'Top Right Corner'.
    GLSGEN_GLSNINEPATCH_EXPORT Vector TextureTRC() const { return _textureTRC; }
 
    /// Setter function for the height of the GlsNinePatch in logical units.
    /// \param value Sets the height of the GlsNinePatch in the direction of _radii[1].
    GLSGEN_GLSNINEPATCH_EXPORT void Height( const float& value );
 
    /// Setter function for the width of the GlsNinePatch in logical units.
    /// \param value Sets the width of the GlsNinePatch in the direction of _radii[0].
    GLSGEN_GLSNINEPATCH_EXPORT void Width( const float& value );
 
    /// Getter function for the height of the GlsNinePatch in logical units.
    /// \return The height of the NinePatch.
    GLSGEN_GLSNINEPATCH_EXPORT float Height() const { return _height; }
 
    /// Getter function for the width of the GlsNinePatch in logical units.
    /// \return The width of the NinePatch.
    GLSGEN_GLSNINEPATCH_EXPORT float Width() const { return _width; }
 
    /// \return A pointer to the patch vertices.
    virtual GLSGEN_GLSNINEPATCH_EXPORT const Vertex* GetPatchVerts();
 
    /// \return A pointer to the texture points.
    virtual GLSGEN_GLSNINEPATCH_EXPORT const Vector* GetPatchTex();
 
    /// Gets the "child" rectangle. The child rectangle refers to the
    /// inner rectangle of the nine patch, which is where normal content would be drawn.
    /// \return The bounding box of the child rectangle.
    GLSGEN_GLSNINEPATCH_EXPORT Rect3D GetChildRect();
 
    /** Sets the reference texture width, which allows the nine patch to respond to changes of texture size.
      * \param value The reference width of the texture in pixel units
      * \note Setting this value is optional, but if it is not set and the physical texture size changes, the
      *  nine patch will not display will need to be reconfigured by hand. The reference width should
      *  generally be the width of the original texture. It will be automatically updated when image changes
      *  are detected.
      * \sa ReferenceTextureWidth()
      */
    GLSGEN_GLSNINEPATCH_EXPORT void ReferenceTextureWidth( const unsigned int& value );
 
    /** Sets the reference texture height, which allows the nine patch to respond to changes of texture size.
      * \param value The reference height of the texture in pixel units
      * \note Setting this value is optional, but if it is not set and the physical texture size changes, the
      *  nine patch will not display will need to be reconfigured by hand. The reference height should
      *  generally be the height of the original texture. It will be automatically updated when image changes
      *  are detected.
      * \sa ReferenceTextureHeight()
      */
    GLSGEN_GLSNINEPATCH_EXPORT void ReferenceTextureHeight( const unsigned int& value );
 
    /// Gets the reference texture width, which allows the nine patch to respond to changes of texture size.
    /// \sa ReferenceTextureWidth()
    /// \return The width of the nine patch texture in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT unsigned int ReferenceTextureWidth();
 
    /// Gets the reference texture height, which allows the nine patch to respond to changes of texture size.
    /// \sa ReferenceTextureHeight()
    /// \return The height of the nine patch texture in pixels.
    GLSGEN_GLSNINEPATCH_EXPORT unsigned int ReferenceTextureHeight();
 
    /** Forces the nine patch to recalculate it's verts and it's texture verts.
      * \sa ForceRecalculate()
      */
    GLSGEN_GLSNINEPATCH_EXPORT void ForceRecalculate();
 
protected:
    /** Calculate the vertices for the nine patches */
    void CalculatePatchVerts();
 
    /** Calculate the texture coordinates for the nine patches */
    void CalculateTextureVerts();
 
    /// Calculates new values when a texture has been upsized or downsized.
    /// \param tw The new texture width in pixels.
    /// \param th The new texture height in pixels.
    void CalculateTextureResize( const int tw, const int th );
 
    /** Calculates _width, _height and _normal based on _radii */
    void CalculateRadiiUnit();
 
    /** callback called when the 9patch needs to be recalculated */
    void SetNeedsRecalculate();
 
    /** callback called when the 9patch texture coordinates need to be recalculated  */
    void SetNeedsTextureRecalculate();
 
    /** Draws a grid displaying the 9 polygons on top of the image */
    void DrawGuides();
 
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLS_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif
 
#ifndef GLES
    /// Helper routine to draw the 9 patches.
    /// \note Not normally called by users.
    /// \param texture If true, draw with texturing enabled.
    void DrawPatches( bool texture );
 
    /** Performs OpenGL drawing commands */
    void DrawGeometry();
#endif
 
    /** Array of vertices that defines the NinePatch, arranged as follows:
      *   12--13---14---15
      *   |    |    |    |
      *   8----9---10---11
      *   |    |    |    |
      *   4----5----6----7
      *   |    |    |    |
      *   0----1----2----3
      */
    Vertex _patchVerts[ GLS_NINE_PATCH_ARRAY_SIZE ];
 
    /** Array of texture coordinates, arranged the same way as _patchVerts */
    Vector _patchTex[ GLS_NINE_PATCH_ARRAY_SIZE ];
 
    /** Radius vectors that define the size of the NinePatch
      * _radii[0] defines the width
      * _radii[1] defines the height
      */
    Vector _radii[ 2 ];
 
    Vector _normal;     /**< Surface normal of the NinePatch. Computed from the _radii */
    Vector _textureBLC; /**< Texture coordinate of bottom left corner of NinePatch */
    Vector _textureTRC; /**< Texture coordinate of top right corner of NinePatch */
    float  _width;      /**< Width of the NinePatch in the direction of _radii[0] */
    float  _height;     /**< Height of the NinePatch in the direction of _radii[1] */
 
    /** Values representing the distance from the edge of the texture that makes up the
      * NinePatch borders.  Units are in pixels and are the distance IN from the edge of the texture.
      */
    float _textureEdge[ 4 ];
 
    /** Values representing the size of edges of the NinePatch.  Units are in logical units measure
      * going IN  from the edge of the NinePatch
      */
    float _vertexEdge[ 4 ];
 
    bool         _centerVisible;           /**< Whether or not the center patch will be drawn */
    bool         _needsRecalculate;        /**< True when the vertices need to be recalculated */
    bool         _needsTextureRecalculate; /**< True when the texture coordinates need to be recalculated */
    bool         _guidesVisible;           /**< If true, then "guides" will be drawn".  Normally only set in the editor */
    GlsColor     _objectColor;             /**< Fill color is normally stored in vertices, but we're not using these in GlsNinePatch */
    unsigned int _texWidth;                /**< Texture Width */
    unsigned int _texHeight;               /**< Texture Height */
 
#ifdef GLES
    GlsVertexArray _vertArray;
    GlsIndexArray  _indexArray;
#endif
 
    unsigned int _referenceTexWidth;  /**< Texture Width when the object was configured.  Used to correctly adjust for new texture resolutions. */
    unsigned int _referenceTexHeight; /**< Texture Height when the object was configured.  Used to correctly adjust for new texture resolutions. */
};
 
} // namespace disti
 
#endif