gls_poly_line.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsPolyLine class.
 
  \par Copyright Information
 
  Copyright (c) 2016 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 INCLUDED_GLS_POLYLINE_H
#define INCLUDED_GLS_POLYLINE_H
#include "dynamic_array.h"
#include "glpolygon.h"
#include "gls_cpp_lang_support.h"
#include "gltrimesh.h"
 
#ifdef GLES
#    include "gls_vertex_array.h"
#endif
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSPOLYLINE ) || defined( GLSGEN_IMPORT_GLSPOLYLINE ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSPOLYLINE ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GLSPOLYLINE_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSPOLYLINE_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSPOLYLINE_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_poly_line"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
// SetValue enumerations
enum
{
    GLS_POLY_LINE_FIRST_VALUE = GLS_LAST_INITIALIZER + 1,
    GLS_POLY_LINE_THICKNESS,
    GLS_POLY_LINE_HALO,
    GLS_POLY_LINE_HALO_COLOR,
    GLS_POLY_LINE_HALO_THICKNESS,
    GLS_POLY_LINE_NORMAL,
    GLS_POLY_LINE_LAST_INITIALIZER = GLS_POLY_LINE_NORMAL
};
 
/// \details The GlsPolyLineVertex struct. Describes a vertex generated by GlsPolyLine.
typedef struct
{
    Vector vertex;   /**< The vertex coordinate */
    Vector texCoord; /**< The texture coordinate */
    Vector normal;   /**< The vertex normal */
} GlsPolyLineVertex;
 
/// \details The GlsPolyLineFace struct. Describes a face generated by GlsPolyLine.
typedef struct
{
    GlsPolyLineVertex a; ///< The first vertex of the face.
    GlsPolyLineVertex b; ///< The second vertex of the face.
    GlsPolyLineVertex c; ///< The third vertex of the face.
} GlsPolyLineFace;
 
/** Runtime implementation of a GlsPolyLine */
class GlsPolyLine : public GLPolygon
{
    friend class GlsPolyLineEditor;
 
private:
    GlsPolyLine& operator=( const GlsPolyLine& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsPolyLine( const GlsPolyLine& ) 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.
    typedef DynamicArray<GlsPolyLineFace> GlsPolyLineTriangleList; ///< Typedef for a list of triangles.
 
    /** Create a new GlsPolyLine.*/
    GLSGEN_GLSPOLYLINE_EXPORT GlsPolyLine();
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name for this object.
    GLSGEN_GLSPOLYLINE_EXPORT GlsPolyLine( const GlsPolyLine& that, const bool generateNames );
 
    /** Destructs a GlsPolyLine object */
    virtual GLSGEN_GLSPOLYLINE_EXPORT ~GlsPolyLine();
 
    /// \return A pointer to a new GlsPolyLine object.
    static GLSGEN_GLSPOLYLINE_EXPORT DisplayObject* CreateInstance();
 
    virtual GLSGEN_GLSPOLYLINE_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void           GetExtents( float& minx, float& miny, float& minz, float& maxx, float& maxy, float& maxz ) DISTI_METHOD_OVERRIDE;
 
    using BaseClass::SetColor;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void SetColor( const GlsColor& color ) DISTI_METHOD_OVERRIDE;
 
    using BaseClass::SetFillColor;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void SetFillColor( const GlsColor& color ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSPOLYLINE_EXPORT void CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void CopyGeometry( DisplayObject* srcArg ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GLSPOLYLINE_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSPOLYLINE_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::Scale;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar ) DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::Rotate;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSPOLYLINE_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
 
    /* Unhides base class implementation. */
    using BaseClass::PolygonEnd;
    virtual GLSGEN_GLSPOLYLINE_EXPORT void PolygonEnd( const int end ) DISTI_METHOD_OVERRIDE;
 
    //////////////////////////////////////////////////
    // GlsPolyLine specific operations
    //////////////////////////////////////////////////
 
    /** Sets the line thickness
      * \param val  The new line thickness in logical units
      */
    GLSGEN_GLSPOLYLINE_EXPORT void Thickness( const float& val );
 
    /** Gets the line thickness
      * \return The line thickness in logical units
      */
    GLSGEN_GLSPOLYLINE_EXPORT float Thickness() { return _thickness; }
 
    /// \return The normal for the polyline.
    GLSGEN_GLSPOLYLINE_EXPORT Vector GlobalNormal() { return _normal; }
 
    /// Enable/Disable halo.
    /// \param val The new halo enabled state.
    GLSGEN_GLSPOLYLINE_EXPORT void Halo( const bool& val );
 
    /// \return The halo enabled state.
    GLSGEN_GLSPOLYLINE_EXPORT bool Halo() { return _halo; }
 
    /// Set the halo color.
    /// \param val The new halo color to set.
    GLSGEN_GLSPOLYLINE_EXPORT void HaloColor( const GlsColor& val );
 
    /// \return The halo color.
    GLSGEN_GLSPOLYLINE_EXPORT GlsColor HaloColor() { return _haloColor; }
 
    /** Set the halo thickness 
      * \param val  The new halo thickness in logical units
      */
    GLSGEN_GLSPOLYLINE_EXPORT void HaloThickness( const float& val );
 
    /** Get the halo thickness
      * \return The line thickness in logical units
      */
    GLSGEN_GLSPOLYLINE_EXPORT float HaloThickness() { return _haloThickness; }
 
    virtual GLSGEN_GLSPOLYLINE_EXPORT void SetVertices( unsigned int nPoints, Vertex* vertices ) DISTI_METHOD_OVERRIDE;
 
    GLSGEN_GLSPOLYLINE_EXPORT void DeleteVertexAt( unsigned int index ) DISTI_METHOD_OVERRIDE;
 
    /** Set the recalculate flag for the object to force it to recalculate
     */
    virtual GLSGEN_GLSPOLYLINE_EXPORT void SetRecalculate();
 
protected:
#ifdef GLES
    // These are helper functions, only used for GLES, and should not be considered missing external api
    GLSGEN_GLSPOLYLINE_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
    void                           BakeVBO( GlsVertexArray& vbo, GlsPolyLineTriangleList& vertices, GlsColor color );
    void                           BakeLinesVBO( GlsVertexArray& vbo, GlsPolyLineTriangleList& vertices );
 
    GlsVertexArray _gles_triangles;
    GlsVertexArray _gles_haloTriangles;
    GlsVertexArray _gles_antiAliasLines;
#endif
 
    GlsPolyLineTriangleList _triangles; ///< The triangles to render, derived from vertices and thickness.
    float                   _thickness; ///< The thickness of the line in logical units.
    Vector                  _normal;    ///< The normal vector (for all triangles).
 
    bool                    _halo;          ///< If true, a halo (outline) will be drawn.
    GlsColor                _haloColor;     ///< The color of the halo.
    float                   _haloThickness; ///< The thickness of the halo in logical units.
    GlsPolyLineTriangleList _haloTriangles; ///< The triangles to render, derived from vertices and halo thickness.
 
    bool _needsRecalculate; ///< If true, the triangles will be recalculated the next frame.
 
    unsigned int _endCapIndex; ///< The index of the triangle forming the end cap.
 
    /// Updates the end-cap hang over for the halos.
    /// \note Not normally called by users.
    void UpdateHaloEndCaps();
 
    /// Notify that vertices have changed, updates bounding volume and sets recalculate for polyline.
    /// \note Not normally called by users.
    void VerticesChanged();
 
    /// Computes the geometry for the line segments and invokes the appropriate corner method.
    /// \note Not normally called by users.
    void ComputeSegments();
 
    /// ComputeSegments helper method.
    /// \note Not normally called by users.
    /// \param array The returned computed triangle list.
    /// \param thickness The thickness in logical units.
    /// \param calculatingHalos If true will use halo specific logic during calculation.
    void ComputeSegments( GlsPolyLineTriangleList& array, float thickness, bool calculatingHalos = false );
 
    /// Compute a corner.
    /// \note Not normally called by users.
    /// \param array The returned computed triangle list.
    /// \param thickness The thickness in logical units.
    /// \param cornerRadius The corner radius in logical units.
    /// \param refVert The vertex at this corner.
    /// \param v1
    /// \param v2
    /// \param v3
    /// \param v4
    /// \param l1 Vector from refVert to the previous vertex.
    /// \param l2 Vector refVert to the next vertex.
    /// \param calculatingHalos If true will use halo specific logic during calculation.
    void ComputeCorner( GlsPolyLineTriangleList& array, float thickness, float cornerRadius, const Vector& refVert, const Vector& v1, const Vector& v2, const Vector& v3, const Vector& v4, const Vector& l1, const Vector& l2, bool calculatingHalos = false );
 
    /// Helper method to draw a list of triangles.
    /// \note Not normally called by users.
    /// \param array The triangle list to draw.
    void DrawTriangles( GlsPolyLineTriangleList& array );
};
 
} // namespace disti
 
#endif