gls_nine_patch.h

Go to the documentation of this file.

#ifndef _GLS_NINE_PATCH_H
#define _GLS_NINE_PATCH_H
 
/*! \file gls_nine_patch.h
\brief  This header defines the GlsNinePatch class in
        the GL Studio DO-178B Runtime Library.
 
\par Copyright Information
Copyright (C) 1999-2008 by Distributed Simulation Technology, Inc. (DiSTI)<br>
Orlando, FL USA<br>
All rights reserved.<br>
 
  This file is copyrighted software and contains proprietary trade secrets of
DiSTI, and embodies substantial creative efforts as well as confidential
information, ideas, and expressions.
 
  Permission to use, and copy this software and its documentation for any
purpose is hereby granted per the Distribution Agreement and/or the Licensing
Agreement signed with DiSTI. This permission is granted provided that:
    1.  The above copyright notice appears in all copies.
    2.  That both the copyright notice and this permission notice appear in
        the supporting documentation.
    3.  That the names DiSTI and GL Studio not be used in advertising or
        publicity pertaining to distribution of the software without specific,
        written prior permission of DiSTI.
 
  Permission to modify the software is granted, but not the right to
distribute the source code whether modified, or non-modified.  Modifying the
software might invalidate the DO-178B certification package.
 
  Permission to distribute binaries produced by compiling source code, or
modified source code is granted, provided you:
    1.  Provide your name and address as the primary contact for the support
        of your modified version.
    2.  Retain our contact information in regard to use of the base software. 
 
   DiSTI does not provide warranty for this software or guarantee that it
satisfies any specification or requirement unless otherwise stated in a
specific contractual arrangement between the customer and DiSTI.
 
*** NOTICE *** This source code is not encompassed by the DO-178B certication
package.
 
*/
 
#include "gls_include.h"
#include "gls_render_object.h"
#include "gls_vertex.h"
#include "gls_texture_vertex_array.h"
#include "gls_state_manager.h"
#include "gls_class_invariant.h"
 
/** The GlsNinePatch abstracts a set of nine polygons which contain edges that maintain the same width/height
  * after scaling the object.
  * \invariant base class invariant holds,
  *            _vertices[].IsValid() for all vertices,
  *             _vertexEdge[] > 0 for all vertex edges,
  *             _textureEdge[] > 0 for all texture edges,
  */
class GlsNinePatch : public GlsRenderObject
{
public:
    GLS_CLASS_INVARIANT_DECLARATION( GlsNinePatch )
 
    // enumeration for the indicies into _vertexEdge and _textureEdge that represent the outer four sides for the nine patch
    enum Edge
    {
        EDGE_LEFT = 0u,
        EDGE_RIGHT = 1u,
        EDGE_TOP = 2u,
        EDGE_BOTTOM = 3u,
        NUM_EDGES = 4u
    };
 
    // enumeration for constants used while drawing
    enum
    {
        NUM_VERTS = 16u,
        NUM_DRAW_VERTS_NO_CENTER = 32u,
        NUM_DRAW_VERTS = 36u
    };
 
    // enumeration for the indicies into _vertices that represent the four corners of the nine patch
    enum
    {
        LOWER_LEFT_CORNER_INDEX = 0u,
        LOWER_RIGHT_CORNER_INDEX = 3u,
        UPPER_LEFT_CORNER_INDEX = 12u,
        UPPER_RIGHT_CORNER_INDEX = 15u
    };
 
    /** initialization parameters for the GlsNinePatch */
    struct InitParameters
    {
        const GlsRenderObject::InitParameters       renderInitParameters;       /**< base class initialization */
 
        const GlsTextureVertex                      vertices[NUM_VERTS];        /**< initial vertices */
        const GlsUInt32                             textureEdges[NUM_EDGES];    /**< initial texture edges in pixels. */
                                                                                /**< values range from 0 to  */
        const GlsFloat32                            vertexEdges[NUM_EDGES];     /**< initial vertex edges */
                                                                                /**< values range from 0 to  */
        const GlsBool                               centerVisible;              /**< initial center draw setting */
 
        #if defined( GLS_DEBUG )
            /** Determine if the initialization parameters are valid ( GLS_DEBUG only )
              * \return GLS_TRUE if valid else GLS_FALSE
              * \pre none
              * \post none
              */
            GlsBool IsValid( void ) const;
        #endif // GLS_DEBUG
    };
 
    /** Constructor - create instance
      * \param initParameters initialization parametets
      * \param eventDispatcher event dispatcher for this object else GLS_NULL
      * \pre initParameters.IsValid()
      * \post instance created
      */
    GlsNinePatch( const InitParameters &initParameters, GlsEventDispatcher* const eventDispatcher );
 
    /** Draws this nine patch
      * \param gl GL State manager for OpenGL into which polygon is drawn
      * \param time the elaspsed time in seconds since program start
      * \pre time >= 0.0
      * \post polygon is drawn to OpenGL if visible and not blinked off, _previousDynamicScale = _dynamicScale
      */
    virtual void Draw( GlsStateManager &gl, const GlsFloat64 time );
 
    /** Offset the texture on the object
      * \param offset x, y offset for texture
      * \pre offset.IsValid()
      * \post offset is added to the texture coordinates
      */
    virtual void OffsetTexture( const GlsVector2D &offset );
 
    /** Sets the texture edge value IN from the nine patch defined bounding region
      * \param edge enumerated above
      * \param value in pixel measurements
      * \pre edge < NUM_EDGES, value >= 0,
      *      initial texture edge value at object creation must be have been > 0
      * \post object texture edge has new value
      */
    void SetTextureEdge( const Edge edge, const GlsUInt32 value );
 
    /** Sets the vertex edge value IN from the nine patch defined bounding region
      * \param edge enumerated above
      * \param value in unit measurements
      * \pre edge < NUM_EDGES, value >= 0.0
      * \post object vertex edge has new value
      */
    void SetVertexEdge( const Edge edge, const GlsFloat32 value );
 
    /** Sets whether the center is drawn or not
      * \param visible boolean to control visibility of center quad
      * \pre none
      * \post object has new condition for drawing center
      */
    void SetCenterVisible( const GlsBool visible );
 
protected:
    
    /** 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
      */
    GlsTextureVertex _vertices[ NUM_VERTS ];    /**< array of vertices and texture vertices for nine patch */
    GlsTextureVertex _unalteredVertices[ NUM_VERTS ]; /**< array of vertices and texture vertices that are unaltered from initialization */
 
    GlsUInt32 _textureEdge[ NUM_EDGES ];        /**< 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. */
    GlsUInt32 _unalteredTextureEdge[ NUM_EDGES ]; /**< Values representing the original 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. */
    GlsFloat32 _vertexEdge[ NUM_EDGES ];          /**< Values representing the size of edges of the NinePatch.  Units are in logical units measure */
                                                /**< going IN  from the edge of the NinePatch */
                                                /**< Values range from 0.0f to the total width of the nine patch minus the opposite edge. */
 
    GlsBool _centerVisible;                     /**< Whether or not the center patch will be drawn */
 
    GlsVector2D      _currentTextureOffset;     /**< current texture offset accumulated by OffsetTexture() */
 
    /** Returns whether the total width or height is greater than the opposite edges combined
      * \return GLS_TRUE if it is non-degenerate else GLS_FALSE
      * \pre none
      * \post none
      */
    const GlsBool SizeIsNonDegenerate( void ) const;
 
    /** Output the vertices in the array to GL
      * \param gl GL state manager to receive verts
      * \param doTextureCoordinates GLS_TRUE to send texture coordinates with each vert else GLS_FALSE
      * \param doVertexColors GLS_TRUE to send vertex colors with each vert else GLS_FALSE
      * \pre called inside a GL begin/end pair
      * \post vertices are output to GL
      */
    void OutputVertices( GlsStateManager &gl, const GlsBool doTextureCoordinates, const GlsBool doVertexColors ) const;
 
    /** Output the vertices in the array to GL
      * \param gl GL state manager to receive verts
      * \param doTextureCoordinates GLS_TRUE to send texture coordinates with each vert else GLS_FALSE
      * \param doVertexColors GLS_TRUE to send vertex colors with each vert else GLS_FALSE
      * \pre called inside a GL begin/end pair
      * \post vertices are output to GL
      */
    void OutputCornerVertices( GlsStateManager &gl ) const;
 
    /** Adjusts the vertices based on the current texture and vertex edge settings.
      * \pre none
      * \post vertices are adjusted based on current texture and vertex edge settings
      */
    void RefactorVerts( void );
 
    /** Destructor - shall never be called
      * \pre none
      * \post none 
      */
    virtual ~GlsNinePatch();
 
private:
    typedef GlsRenderObject _BaseClass; /**< base class alias */
 
    // Disable implicit generated Members
    GlsNinePatch& operator=( const GlsNinePatch &rhs );
    GlsNinePatch( const GlsNinePatch &src );
};
 
#if defined( GLS_DEBUG )
#pragma BullseyeCoverage save off
/** Determine if the given edge is valid ( GLS_DEBUG only )
  * \param edge nine patch edge in question
  * \return GLS_TRUE if valid else GLS_FALSE
  * \pre none
  * \post none
  */
inline GlsBool GlsNinePatchEdgeIsValid( const GlsNinePatch::Edge edge )
{
    return( ( GlsNinePatch::EDGE_LEFT    == edge ) ||
            ( GlsNinePatch::EDGE_RIGHT == edge ) ||
            ( GlsNinePatch::EDGE_TOP == edge ) ||
            ( GlsNinePatch::EDGE_BOTTOM == edge ) );
 
}
#pragma BullseyeCoverage restore
#endif // GLS_DEBUG
 
#endif // _GLS_POLYGON_H