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

#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
};

typedef struct
{
    Vector vertex;   /**< The vertex coordinate */
    Vector texCoord; /**< The texture coordinate */
    Vector normal;   /**< The vertex normal */
} GlsPolyLineVertex;

typedef struct
{
    GlsPolyLineVertex a, b, c;
} 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;
    typedef GLPolygon                     BaseClass;
    typedef DynamicArray<GlsPolyLineFace> GlsPolyLineTriangleList;

    /** Create a new GlsPolyLine.*/
    GLSGEN_GLSPOLYLINE_EXPORT GlsPolyLine();

    GLSGEN_GLSPOLYLINE_EXPORT GlsPolyLine( const GlsPolyLine& that, const bool generateNames );

    /** Destructs a GlsPolyLine object */
    virtual GLSGEN_GLSPOLYLINE_EXPORT ~GlsPolyLine();

    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( void ) 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;

    /** Sets the polygon end mode (Open or Closed) for the polygon
      * \param end  Enumeration indicating open or closed mode
      * \sa PolygonClose_e
      */
    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( void ) { return _thickness; }

    /** Get the normal for the polyline **/
    GLSGEN_GLSPOLYLINE_EXPORT Vector GlobalNormal( void ) { return _normal; }

    /** Enable/Disable halo */
    GLSGEN_GLSPOLYLINE_EXPORT void Halo( const bool& val );

    /** Get the halo setting */
    GLSGEN_GLSPOLYLINE_EXPORT bool Halo( void ) { return _halo; }

    /** Set the halo color */
    GLSGEN_GLSPOLYLINE_EXPORT void HaloColor( const GlsColor& val );

    /** Get the halo color */
    GLSGEN_GLSPOLYLINE_EXPORT GlsColor HaloColor( void ) { 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( void )
    {
        return _haloThickness;
        _needsRecalculate = true;
    }

    /** Sets the vertex data for this polygon
      * You should call UpdateBoundingVolume after changing an objects extents.
      * \sa UpdateBoundingVolume
      * \param nPoints  The number of vertices in the object
      * \param vertices  The vertex data for the object
      */
    virtual GLSGEN_GLSPOLYLINE_EXPORT void SetVertices( unsigned int nPoints, Vertex* vertices ) DISTI_METHOD_OVERRIDE;

    /** see base class */
    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( void );

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

    GlsPolyLineTriangleList _triangles;
    float                   _thickness;
    Vector                  _normal;

    bool                    _halo;
    GlsColor                _haloColor;
    float                   _haloThickness;
    GlsPolyLineTriangleList _haloTriangles;

    bool _needsRecalculate;

    unsigned int _endCapIndex;

    /** updates the end-cap hang over for the halos */
    void UpdateHaloEndCaps();

    /** notify that vertices have changed
      * updates bounding volume and sets recalculate for polyline
      */
    void VerticesChanged( void );

    /** Computes the geometry for the line segments and invokes the appropriate corner method */
    void ComputeSegments( void );
    /** ComputeSegments helper method */
    void ComputeSegments( GlsPolyLineTriangleList& array, float thickness, bool calculatingHalos = false );
    /** Compute a corner */
    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 );

    void DrawTriangles( GlsPolyLineTriangleList& array );
};

} // namespace disti

#endif