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
///////////////////////////////////////////////////////////////////////////////

#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

/** 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;
    typedef GLPolygon BaseClass;

    class Rect3D
    {
    public:
        Vector blc, brc, trc;

        Rect3D(){};
    };

    ///////////////////////////////////////////////////////////////////////////////////////////////
    //
    // DisplayObject overrides
    //
    ///////////////////////////////////////////////////////////////////////////////////////////////
    virtual GLSGEN_GLSNINEPATCH_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar );
    virtual GLSGEN_GLSNINEPATCH_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis );
    virtual GLSGEN_GLSNINEPATCH_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint );
    virtual GLSGEN_GLSNINEPATCH_EXPORT Vertex* Vertices();
    virtual GLSGEN_GLSNINEPATCH_EXPORT void    GetExtents( float& minx, float& miny, float& minz, float& maxx, float& maxy, float& maxz );
    virtual GLSGEN_GLSNINEPATCH_EXPORT void    GetTransformedExtents( Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax );

    virtual GLSGEN_GLSNINEPATCH_EXPORT void UpdateBoundingVolume( void );

    virtual GLSGEN_GLSNINEPATCH_EXPORT void SetValue( int spec, va_list& args );
    GLSGEN_GLSNINEPATCH_EXPORT              GlsNinePatch( bool generateInstance = false );
    GLSGEN_GLSNINEPATCH_EXPORT              GlsNinePatch( const GlsNinePatch& that, const bool generateNames );
    virtual GLSGEN_GLSNINEPATCH_EXPORT ~GlsNinePatch();
    static GLSGEN_GLSNINEPATCH_EXPORT DisplayObject* CreateInstance();
    virtual GLSGEN_GLSNINEPATCH_EXPORT void          SetAvailableAttributes( unsigned int value );
    virtual GLSGEN_GLSNINEPATCH_EXPORT DisplayObject* CloneObject( bool generateNames = false );
    virtual GLSGEN_GLSNINEPATCH_EXPORT void           CopyProperties( DisplayObject* src );
    virtual GLSGEN_GLSNINEPATCH_EXPORT void           CopyGeometry( DisplayObject* srcArg );
#ifndef GLES
    virtual GLSGEN_GLSNINEPATCH_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL );
    virtual GLSGEN_GLSNINEPATCH_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array );
#endif

    virtual GLSGEN_GLSNINEPATCH_EXPORT void Calculate( double time );

#ifdef GLES
    virtual GLSGEN_GLSNINEPATCH_EXPORT void PreDraw( const OpenGLMatrices& current, Culler& culler );
#endif
    virtual GLSGEN_GLSNINEPATCH_EXPORT void Draw( void );
    virtual GLSGEN_GLSNINEPATCH_EXPORT void SetFillColor( const GlsColor& color );
    virtual GLSGEN_GLSNINEPATCH_EXPORT GlsColor GetFillColor( void );

    /** 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( void ) { 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 ) {} // 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 );
    GLSGEN_GLSNINEPATCH_EXPORT void LeftTextureEdge( float value ) { TextureEdge( LEFT, value ); }
    GLSGEN_GLSNINEPATCH_EXPORT void RightTextureEdge( float value ) { TextureEdge( RIGHT, value ); }
    GLSGEN_GLSNINEPATCH_EXPORT void TopTextureEdge( float value ) { TextureEdge( TOP, value ); }
    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 );
    GLSGEN_GLSNINEPATCH_EXPORT void LeftVertexEdge( float value ) { VertexEdge( LEFT, value ); }
    GLSGEN_GLSNINEPATCH_EXPORT void RightVertexEdge( float value ) { VertexEdge( RIGHT, value ); }
    GLSGEN_GLSNINEPATCH_EXPORT void TopVertexEdge( float value ) { VertexEdge( TOP, value ); }
    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 );
    GLSGEN_GLSNINEPATCH_EXPORT float         LeftTextureEdge() { return TextureEdge( LEFT ); }
    GLSGEN_GLSNINEPATCH_EXPORT float         RightTextureEdge() { return TextureEdge( RIGHT ); }
    GLSGEN_GLSNINEPATCH_EXPORT float         TopTextureEdge() { return TextureEdge( TOP ); }
    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 );
    GLSGEN_GLSNINEPATCH_EXPORT float         LeftVertexEdge() { return VertexEdge( LEFT ); }
    GLSGEN_GLSNINEPATCH_EXPORT float         RightVertexEdge() { return VertexEdge( RIGHT ); }
    GLSGEN_GLSNINEPATCH_EXPORT float         TopVertexEdge() { return VertexEdge( TOP ); }
    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 use know that the Center of the NinePatch is visible.
      */
    GLSGEN_GLSNINEPATCH_EXPORT bool CenterVisible() { return _centerVisible; }

    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( void ) 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( void ) 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 );
    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 );
    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 Returns the vector in pixel units for the value of the 'Bottom Left Corner'
      */
    GLSGEN_GLSNINEPATCH_EXPORT Vector TextureBLC( void ) const { return _textureBLC; }

    /** Getter function for the top right corner of the texture in the GLSNinePatch
      * \return Returns the vector in pixel units for the value of the 'Top Right Corner'
      */
    GLSGEN_GLSNINEPATCH_EXPORT Vector TextureTRC( void ) 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( void ) 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( void ) const { return _width; }

    /** Returns a pointer to the patch vertices*/
    virtual GLSGEN_GLSNINEPATCH_EXPORT const Vertex* GetPatchVerts();

    /** Returns 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
      */
    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()
      */
    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()
      */
    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 */
    void CalculateTextureResize( const int tw, const int th );

    /** Calculates _width, _height and _normal based on _radii */
    void CalculateRadiiUnit( void );

    /** callback called when the 9patch needs to be recalculated */
    void SetNeedsRecalculate( void );

    /** callback called when the 9patch texture coordinates need to be recalculated  */
    void SetNeedsTextureRecalculate( void );

    /** Draws a grid displaying the 9 polygons on top of the image */
    void DrawGuides( void );

#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 );
#endif

#ifndef GLES
    /** Helper routine to draws the 9 patches */
    void DrawPatches( bool texture );

    /** Performs OpenGL drawing commands */
    void DrawGeometry( void );
#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