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) 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.
*/
 
#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
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#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:
    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.
    friend class GlsSchematicPolyLineInterconnectEditor;
 
    GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GlsSchematicPolyLineInterconnect();
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name for this object.
    GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GlsSchematicPolyLineInterconnect( const GlsSchematicPolyLineInterconnect& that, const bool generateNames );
 
    /** Destructs a GlsSchematicPolyLineInterconnect object */
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT ~GlsSchematicPolyLineInterconnect();
 
    /// \return A pointer to a new GlsSchematicPolyLineInterconnect object.
    static GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT DisplayObject* CreateInstance();
 
    //////////////////////////////////////////////////
    // Overridden base class methods
    //////////////////////////////////////////////////
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void           CopyGeometry( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void           CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void Calculate( double time ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void CalculateTextureCoordinates() DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT DisplayObject* handle( DisplayEvent* ev ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar = 0 ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void GetExtents( float& x, float& y, float& z, float& x1, float& y1, float& z1 ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT Vertex WorldVertex( unsigned int i ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void SetVertices( unsigned int nPoints, Vertex* vertices ) DISTI_METHOD_OVERRIDE;
 
    GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void DeleteVertexAt( unsigned int index ) DISTI_METHOD_OVERRIDE;
    GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT void InsertVertexAt( unsigned int index ) DISTI_METHOD_OVERRIDE;
 
    //////////////////////////////////////////////////
    // 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
    /** 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();
 
#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();
#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();
 
protected:
    /** helper struct for storing computed verts for interconnect */
    struct InterconnectVertex
    {
        float _leftX;  ///< Left side X coord in 2D plane.
        float _leftY;  ///< Left side Y coord in 2D plane.
        float _rightX; ///< Right side X coord in 2D plane.
        float _rightY; ///< Right side Y coord in 2D plane.
 
        float _interconnectU; ///< Corresponding U texture coord for interconnect texture.
        float _flowU;         ///< Corresponding U texture coord for flow texture.
 
        /// Constructor
        /// \param leftX Left side X coord in 2D plane.
        /// \param leftY Left side Y coord in 2D plane.
        /// \param rightX Right side X coord in 2D plane.
        /// \param rightY Right side Y coord in 2D plane.
        /// \param interconnectU Corresponding U texture coord for interconnect texture.
        /// \param flowU Corresponding U texture coord for flow texture.
        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> InterconnectVertexArray;
 
    /** helper struct for storing info for corners in the poly line */
    struct CornerCircle
    {
        Vector _v0;            ///< Corner flows from _v0, _v1, _v2.
        Vector _v1;            ///< Corner flows from _v0, _v1, _v2.
        Vector _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;    ///< Starting theta for arc in circle making round corner.
        double _endTheta;      ///< 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> CornerCircleArray;
 
    /** array of Vector */
    typedef DynamicArray<Vector> VectorArray;
 
    /** notify that vertices have changed
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT VerticesChanged();
 
    /** notify that the orientation vectors have changed
      */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT OrientationChanged();
 
    /** get the rotation matrix for the current _orientation vectors
      * \return the rotation matrix for the current _orientation vectors
      */
    virtual GlsMatrixType GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT GetOrientationMatrix();
 
    /** flag line to be rebuilt on next draw */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetRebuild();
 
    /** rebuild the polyline */
    virtual void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT Rebuild();
 
#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 GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT 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();
#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 GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT 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 GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT 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 The corners in question.
    /// \return The length of the computed path.
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT 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.
    /// \return The length of the resulting segment.
    virtual float GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT 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.
    /// \return The size of the resulting corner.
    virtual GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT 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 void GLSGEN_GLSSCHEMATICPOLYLINEINTERCONNECT_EXPORT SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#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