gls_schematic_poly_line_interconnect.h

Go to the documentation of this file.

#ifndef _GLSSCHEMATICPOLYLINEINTERCONNECT_H
#define _GLSSCHEMATICPOLYLINEINTERCONNECT_H
/*! \file
  \brief  The disti::GlsSchematicPolyLineInterconnect class.

  \par Copyright Information

  Copyright (c) 2015 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.
*/

#include "glpolygon.h"
#include "gls_cpp_lang_support.h"

#ifdef GLES
#include "gls_triangle_storage.h"
#else
#include "gls_display_list.h"
#endif

//////////////////// Provides support for creating DLLs ////////////////////////
#if (defined(GLSGEN_EXPORT_GLSSCHEMATICPOLYLINEINTERCONNECT) || \
     defined(GLSGEN_IMPORT_GLSSCHEMATICPOLYLINEINTERCONNECT) || \
     defined(GLS_EXPORT_GENERATED) || \
     defined(GLS_IMPORT_GENERATED)) \
     && defined(_MSC_VER) 
#  if defined(GLSGEN_EXPORT_GLSSCHEMATICPOLYLINEINTERCONNECT) || defined(GLS_EXPORT_GENERATED)
#    define GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT    __declspec(dllexport)
#  else
#    define GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT    __declspec(dllimport)
#  endif
#else
#  define GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////

#define LIB_BASE_NAME "gls_schematic_poly_line_interconnect"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME

namespace disti
{

// SetValue enumerations
enum {
    GLS_SCHEMATICPOLYLINEINTERCONNECT_FIRST_VALUE = GLS_LAST_INITIALIZER+1,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_ORIENTATION,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_LINE_THICKNESS,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_ROUNDED_CORNERS,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_CORNER_RADIUS,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_FORCE_EXACT_CORNER_RADIUS,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_CORNER_SEGMENTS,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_INTERCONNECT_TEXTURE_REPEAT_LENGTH,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_FLOW_TEXTURE_INDEX,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_FLOW_TEXTURE_REPEAT_LENGTH,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_SHOW_FLOW,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_FLOW_RATE,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_SHOW_FLOW_BLINK,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_FLOW_BLINK_RATE,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_FLOW_BLINK_START_COLOR,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_FLOW_BLINK_END_COLOR,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_USE_DISPLAY_LIST,
    GLS_SCHEMATICPOLYLINEINTERCONNECT_LAST_VALUE = GLS_SCHEMATICPOLYLINEINTERCONNECT_USE_DISPLAY_LIST
 };

#ifdef GLES
class GlsGloFileAttribute;
#endif

/** Runtime implementation of a GlsSchematicPolyLineInterconnect */
class GlsSchematicPolyLineInterconnect : public GLPolygon
{
private:
    GlsSchematicPolyLineInterconnect& operator=( const GlsSchematicPolyLineInterconnect& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsSchematicPolyLineInterconnect( const GlsSchematicPolyLineInterconnect& ) DISTI_SPECIAL_MEM_FUN_DELETE;

public:   
    typedef GLPolygon _BaseClass;
    friend class GlsSchematicPolyLineInterconnectEditor;

    /** Create a new GlsSchematicPolyLineInterconnect.
      * for this inputdevice */
    GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GlsSchematicPolyLineInterconnect( void );
    GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GlsSchematicPolyLineInterconnect( const GlsSchematicPolyLineInterconnect& that, const bool generateNames );

    /** Destructs a GlsSchematicPolyLineInterconnect object */
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT ~GlsSchematicPolyLineInterconnect();

    static GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT DisplayObject* CreateInstance();

    //////////////////////////////////////////////////
    // Overridden base class methods
    //////////////////////////////////////////////////

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void SetAvailableAttributes(unsigned int value);
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT DisplayObject* CloneObject(bool generateNames = false);
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void CopyGeometry(DisplayObject *src);
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void CopyProperties(DisplayObject *src);

#ifndef GLES
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT InterfaceListType* GetCppInterfaceDescription(InterfaceListType* addToThisList= NULL );
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void GetCppInterfaceDescriptionFree(InterfaceListType* array);
#endif

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void Calculate(double time);
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices,Culler &culler );
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void Draw(void);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void CalculateTextureCoordinates(void);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT DisplayObject* handle(DisplayEvent *ev);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void SetValue(int spec,va_list &args);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void Scale(float px, float py, float pz, Vertex *anchor, int handleBar = 0);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void GetExtents(float &x,float &y,float &z,float &x1,float &y1,float &z1);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT bool Hit(float x,float y,float z,float scale, const Vector& directionVector,Vector* collisionPoint);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void Rotate(const Vector &orig,float angle,const Vector &axis);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT Vertex WorldVertex(unsigned int i);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void SetVertices(unsigned int nPoints,Vertex *vertices);

    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void DeleteVertex(unsigned int index);
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void InsertVertex(unsigned int index);

    //////////////////////////////////////////////////
    // GlsSchematicPolyLineInterconnect specific operations
    //////////////////////////////////////////////////

    /** set the i and j orientation vectors that orient the 2-D schematic in 3 space
      * \param iVector new iVector
      * \param jVector new jVector
      * \pre i and j should be orhogonal
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetOrientationVectors( const Vector &iVector, const Vector &jVector );

    /** get the i and j orientation vectors that orient the 2-D schematic in 3 space
      * \param iVector [out] iVector
      * \param jVector [out] jVector
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetOrientationVectors( Vector &iVector /*out*/, Vector &jVector /*out*/);

    /** set the line thickness in logical units
      * \param lineThickness new line thickness in logical units
      * \pre lineThickness > 0.0f 
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetLineThickness( const float lineThickness );
    
    /** get the line thickness in logical units
      * \return the line thickness in logical units
      */
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetLineThickness( void );

    /** set rounded corners
      * \param roundedCorners true for rounded corners
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetRoundedCorners( const bool roundedCorners );
    
    /** get rounded corners
      * \return rounded corners
      */
    virtual bool GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetRoundedCorners( void );

    /** set the corner radius in logical units
      * \param cornerRadius new corner radisu in logical units
      * \pre cornerRadius > 0.0f 
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetCornerRadius( const float cornerRadius );
    
    /** get the corner radius in logical units
      * \return the corner radius in logical units
      */
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetCornerRadius( void );

    /** set force exact corner radius
      * \param forceExactCornerRadius true to force rounded corners to use the exact corner radius
      *                               specified by SetCornerRadius(). If true, a corner that cannot be made
      *                               with this radius will not be rounded.
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetForceExactCornerRadius( const bool forceExactCornerRadius );
    
    /** get force exact corner radius state
      * \return force exact corner radius state
      */
    virtual bool GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetForceExactCornerRadius( void );

    /** set the number of segments used in rounded corners
      * \param cornerSegments number of segments to use in rounded corners
      * \pre 2 <= cornerSegments <= 100
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetCornerSegments( const unsigned int cornerSegments );
    
    /** get the number of segments used in rounded corners
      * \return the number of segments used in rounded corners
      */
    virtual unsigned int GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetCornerSegments( void );

    /** set the interconnect texture index 
      * \param interconnectTextureIndex new interconnect texture index else NO_TEXTURE if no interconnect texture
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetInterconnectTextureIndex( const int interconnectTextureIndex );
    
    /** get the interconnect texture index else NO_TEXTURE if no interconnect texture
      * \return the interconnect texture index else NO_TEXTURE if no interconnect texture
      */
    virtual int GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetInterconnectTextureIndex( void );    

    /** set the number of logical units per interconnect texture repeat ( >0.0 ) 
      *  NOTE: number of actual repeats for the whole interconnect is always rounded
      *   to the nearest whole number so that adjacent interconnect's textures lineup
      * \param interconnectTextureRepeatLength new interconnect texture repeat length
      * \pre interconnectTextureRepeatLength > 0.0f 
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetInterconnectTextureRepeatLength( const float interconnectTextureRepeatLength );
    
    /** get the number of logical units per interconnect texture repeat ( >0.0 )
      * \return the number of logical units per interconnect texture repeat ( >0.0 )
      */
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetInterconnectTextureRepeatLength( void );

    /** set the flow texture index 
      * \param flowTextureIndex new flow texture index else NO_TEXTURE if no flow texture
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetFlowTextureIndex( const int flowTextureIndex );
    
    /** get the flow texture index else NO_TEXTURE if no flow texture
      * \return the flow texture index else NO_TEXTURE if no flow texture
      */
    virtual int GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetFlowTextureIndex( void );    

    /** set the number of logical units per flow texture repeat ( >0.0 ) 
      *  NOTE: number of actual repeats for the whole interconnect is always rounded
      *   to the nearest whole number so that adjacent interconnect's textures lineup
      * \param flowTextureRepeatLength new flow texture repeat length
      * \pre flowTextureRepeatLength > 0.0f 
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetFlowTextureRepeatLength( const float flowTextureRepeatLength );
    
    /** get the number of logical units per flow texture repeat ( >0.0 )
      * \return the number of logical units per flow texture repeat ( >0.0 )
      */
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetFlowTextureRepeatLength( void );

    /** set whether or not the flow is displayed
      * \param showFlow true to show flow else false
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetShowFlow( const bool showFlow );
    
    /** get whether or not the flow is displayed
      * \return true if flow is show else false
      */
    virtual bool GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetShowFlow( void );

    /** set the flow rate in "flow textures" / second
      * \param flowRate flow rate in "flow textures" / second
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetFlowRate( const float flowRate );
    
    /** get the flow rate in "flow textures" / second
      * \return the flow rate in "flow textures" / second
      */
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetFlowRate( void );

    /** set whether or not the flow blink is displayed (NOTE: normal flow is not drawn if flow blink is true)
      * \param showFlowBlink true to show flow blink else false
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetShowFlowBlink( const bool showFlowBlink );
    
    /** get whether or not the flow blink is displayed (NOTE: normal flow is not drawn if flow blink is true)
      * \return true if flow blink is shown else false
      */
    virtual bool GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetShowFlowBlink( void );

    /** set the flow blink rate in hz
      * \param flowBlinkRate flow blink rate in hz
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetFlowBlinkRate( const float flowBlinkRate );
    
    /** get the flow blink rate in hz
      * \return the flow blink rate in hz
      */
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetFlowBlinkRate( void );

    /** set the flow blink start color
      * \param startColor flow blink start color
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetFlowBlinkStartColor( const glsColor &startColor );

    /** get the flow blink start color
      * \return the flow blink start color
      */
    virtual glsColor GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetFlowBlinkStartColor( void );

    /** set the flow blink end color
      * \param endColor flow blink end color
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetFlowBlinkEndColor( const glsColor &endColor );

    /** get the flow blink end color
      * \return the flow blink end color
      */
    virtual glsColor GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetFlowBlinkEndColor( void );

#ifndef GLES
    /** enable/disable using display list for drawing
      * \param useDisplayList true to use display list
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetUseDisplayList( const bool useDisplayList );
    
    /** get use display list
      * \return true if using display list for drawing
      */
    virtual bool GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetUseDisplayList( void );
#endif

    /** set the last segment chamfer distance (NOTE: not controllable in editor, usually used by the GlsSchematicTeeInterconnect plugin at runtime)
      * \param endingChamferDistance distance from end of last line segment to start chamfer ( 0.0f to disable )
      * \pre endingChamferDistance >= 0.0f
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetEndingChamferDistance( const float endingChamferDistance );
    
    /** get the last segment chamfer distance (NOTE: not controllable in editor, usually used by the GlsSchematicTeeInterconnect plugin at runtime)
      * \return distance from end of last line segment to start chamfer ( 0.0f to disable )
      */
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetEndingChamferDistance( void );

protected:
    /** helper struct for storing computed verts for interconnect */
    struct InterconnectVertex
    {
        float  _leftX,         _leftY;          /**< left side coord in 2D plane */
        float  _rightX,        _rightY;         /**< left side coord in 2D plane */
        float  _interconnectU;                  /**< corresponding U texture coord for interconnect texture */
        float  _flowU;                         /**< corresponding U texture coord for flow texture */

        /** ctor */
        inline InterconnectVertex( const float leftX = 0.0f, const float leftY = 0.0f, const float rightX = 0.0f, const float rightY = 0.0f,
                                   const float interconnectU = 0.0f, const float flowU = 0.0f ) :
            _leftX( leftX ),                 _leftY( leftY ),
            _rightX( rightX),                _rightY( rightY ),
            _interconnectU( interconnectU ), _flowU( flowU )
        {}
    };

    /** array of InterconnectVertex */
    typedef DynamicArray< InterconnectVertex, true > InterconnectVertexArray;

    /** helper struct for storing info for corners in the poly line */
    struct CornerCircle
    {
        Vector _v0, _v1, _v2;           /**< corner flows from _v0 -> _v1 -> _v2 */
        bool   _isRounded;              /**< true if the corner is to be rounded */
        Vector _center;                 /**< center of circle making round corner */
        float  _radius;                 /**< radius of circle making round corner */
        double _startTheta, _endTheta;  /**< starting and ending theta for arc in circle making round corner */
        bool   _isLeftTurn;             /**< true if corners is a left turn else false */
        Vector _tangent_v0_v1;          /**< tangent point of corner circle on v0 -> v1 */
        Vector _tangent_v1_v2;          /**< tangent point of corner circle on v1 -> v2 */
    };

    /** array of CornerCircle */
    typedef DynamicArray< CornerCircle, true > CornerCircleArray;

    /** array of Vector */
    typedef DynamicArray< Vector, true >       VectorArray;

    /** notify that vertices have changed
      */
    virtual void VerticesChanged( void );

    /** notify that the orientation vectors have changed
      */
    virtual void OrientationChanged( void );

    /** get the rotation matrix for the current _orientation vectors
      * \return the rotation matrix for the current _orientation vectors
      */
    virtual GlsMatrixType GetOrientationMatrix( void );

    /** flag line to be rebuilt on next draw */
    virtual void SetRebuild( void );

    /** rebuild the polyline */
    virtual void Rebuild( void );

#ifdef GLES
    /** prepare and bake the geometry in _interconnectQuads to a VBO as quads and an outline
      * \param drawFlowUVs true to draw with flow UV's else false to draw with interconnect UV's
      */
    virtual void BakeInterconnectGeometry( const bool drawFlowUVs );

    /** Bakes the VBOS 
     */ 
    void BakeVBOs( );
#else
    /** emit the geomentry in _interconnectQuads to OpenGL as quads and an outline
      * \param drawFlowUVs true to draw with flow UV's else false to draw with interconnect UV's
      */
    virtual void EmitInterconnectGeometry( const bool drawFlowUVs );

    /** turn on/off preview Path drawing ( useful for debugging and when the object is selected in the editor )
      * \param enablePreviewPath true to enable else false
      */
    virtual void EnablePreviewPath( const bool enablePreviewPath );

    /** emit the preview path geometry to GL -- mainly used fir debugging and when the line is selected in the editor */
    virtual void EmitPreviewPathGeometry( void );
#endif

    /** Eliminate adjacent vertices that are not unique between each other
      * \param numVertices number of input vertices
      * \param vertices input vertices
      * \return array of unique verts
      */
    virtual VectorArray GetUniqueVerts( const unsigned int numVertices, Vertex *vertices );

    /** Find a corner circle that will fit the corner defined by v0 -> v1 -> v2
      * \param v0 starting point
      * \param v1 corner point
      * \param v2 ending point
      * \param desiredCornerRadius desired radius for corner circle
      * \param minRadius minimum radius for ccorner circle
      * \param forceExactCornerRadius true if the corner can only be rounded with a radius equal to the desiredCornerRadius 
      *                               else false to allow a smaller radius to be used if needed (>minRadius)
      * \param c [out] receives corner info
      * \param forceCircle [optional, defaults to false] true to force a rounded corner to be found
      *                     (used to avoid lack of precision issues when the circle is tangent at the midpoint of either v0 -> v1, or v1 -> v2
      * \return true if a rounded corner was found
      */
    virtual bool FindCornerCircle( const Vector &v0, const Vector &v1, const Vector &v2, const float desiredCornerRadius, const float minRadius, 
                                   const bool forceExactCornerRadius, CornerCircle &c, bool forceCircle = false );

    /** Compute the length of the path described by the given corner array
      * \param cornerCircles corners in question
      */
    virtual float ComputePathLength( CornerCircleArray &cornerCircles );

    /** Add a line segment to the given array of interconnect verts
      * \param interconnectVerts receives line segment is start and finish are not virtually the same point
      * \param start starting point of line segment
      * \param finish finish point of line segment
      * \param lineThickness thickness of line segment
      * \param curLength current length of path at the starting point
      * \param totalLength total length of path that contains the line segment
      * \param numInterconnectRepeats number of interconnect texture repeats over entire path that contains the line segment
      * \param numFlowRepeats number of flow texture repeats over entire path that contains the line segment
      * \param lastSegmentInPath [optional, defaults to false] true if this line segment is the last in the path
      */
    virtual float AddInterconnectLineSegment( InterconnectVertexArray &interconnectVerts, const Vector &start, const Vector &finish, float lineThickness,
                                              float curLength, const float totalLength,
                                              const unsigned int numInterconnectRepeats, const unsigned int numFlowRepeats,
                                              const bool lastSegmentInPath = false ); 

    /** Add a rounded to the given array of interconnect verts
      * \param interconnectVerts receives line segment is start and finish are not virtually the same point
      * \param c info for rounded corner to add
      * \param lineThickness thickness of line segment
      * \param curLength current length of path at the starting point
      * \param totalLength total length of path that contains the line segment
      * \param numInterconnectRepeats number of interconnect texture repeats over entire path that contains the line segment
      * \param numFlowRepeats number of flow texture repeats over entire path that contains the line segment
      */
    virtual float AddInterconnectRoundedCorner( InterconnectVertexArray &interconnectVerts, const CornerCircle &c, float lineThickness,
                                                float curLength, const float totalLength,
                                                const unsigned int numInterconnectRepeats, const unsigned int numFlowRepeats );                                                                  
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void SetFromGloData(GlsGloFileAttribute &data);
#endif
    
    Vector       _orientation[ 2 ];                /**< Two orthogonal vectors defining the orientation */
    float        _lineThickness;                   /**< thickness of line in logical units ( >0.0 )*/
    bool         _roundedCorners;                  /**< true for rounded corners */
    float        _cornerRadius;                    /**< radius for rounded corners ( >0.0 )*/
    bool         _forceExactCornerRadius;          /**< true to force rounded corners to use the exact corner radius
                                                     *  specified by _cornerRadius. If true, a corner that cannot be made with this radius 
                                                     *  will not be rounded. */
    unsigned int _cornerSegments;                  /**< number of segments to use in rounded corners (2 <= cornerSegments <= 100) */
    float        _interconnectTextureRepeatLength; /**< number of logical units per interconnect texture repeat ( >0.0 ) 
                                                     *  NOTE: number of actual repeats for the whole interconnect is always rounded
                                                     *   to the nearest whole number so that adjacent interconnect's textures lineup */
    int         _flowTextureIndex;                 /**< texture index for flow texture else NO_TEXTURE */
    float       _flowTextureRepeatLength;          /**< number of logical units per flow texture repeat ( >0.0 ) 
                                                     *  NOTE: number of actual repeats for the whole interconnect is always rounded
                                                     *   to the nearest whole number so that adjacent interconnect's textures lineup */
    bool        _showFlow;                         /**< true to draw flow in interconnect else false */
    float       _flowRate;                         /**< the flow rate in "flow textures" / second */
    bool        _showFlowBlink;                    /**< true to draw the flow blink else false (NOTE: normal flow is not drawn if flow blink is true) */
    float       _flowBlinkRate;                    /**< rate of flow blink in hz >= 0.0 */
    glsColor    _flowBlinkStartColor;              /**< starting color for flow blink */
    glsColor    _flowBlinkEndColor;                /**< ending color for flow blink */

    bool                      _needsRebuild;             /**< true if the line needs to be rebuilt */
    double                    _lastCalculateTime;        /**< last time stamp given to Calculate() method */
    InterconnectVertexArray   _interconnectVerts;        /**< 2D verts and texture coords computed for interconnect */

#ifndef GLES
    bool                      _useDisplayList;           /**< true to draw using display lists */                           
    GlsDisplayList            _interconnectDisplayList;  /**< display list for drawing interconnect (if using display lists) */
    GlsDisplayList            _flowDisplayList;          /**< display list for drawing flow (if using display lists) */
#endif

    float  _endingChamferDistance; /**< distance from end of last line segment to start chamfer ( 0.0f to disable ) ( >= 0.0f ) */

    bool               _drawPreviewPath;       /**< true to draw the preview path (mainly used in editor) */
    VectorArray        _previewPathPoints;     /**< points in preview path */
    CornerCircleArray  _previewCornerCircles;  /**< corners in preview path */

#ifdef GLES
    GlsTriangleStrip2D _interconnectTris; /**< Triangle strip for the interconnect */
    GlsTriangleStrip2D _flowTris;         /**< Triangle strip for the flows */
#endif
};

} // namespace disti

#endif