gls_angular_scale.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsAngularScale class and global enumerations.
 
  \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.
 
*/
#ifndef _GLS_ANGULAR_SCALE_H
#define _GLS_ANGULAR_SCALE_H
 
#include "glpolygon.h"
#include "gls_cpp_lang_support.h"
 
#ifdef GLES
#    include "gls_quad_storage.h"
#else
#    include "gls_display_list.h"
#endif
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSANGULARSCALE ) || defined( GLSGEN_IMPORT_GLSANGULARSCALE ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSANGULARSCALE ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GLSANGULARSCALE_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSANGULARSCALE_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSANGULARSCALE_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_angular_scale"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
#ifdef GLES
// Forward Declaration
class GlsGloFileAttribute;
#endif
// SetValue enumerations
enum
{
    GLS_ANGULAR_SCALE_FIRST_VALUE = GLS_LAST_INITIALIZER + 1,
    GLS_ANGULAR_SCALE_RADII,
    GLS_ANGULAR_SCALE_DECONFLICT_TICKS,
    GLS_ANGULAR_SCALE_HALO_ENABLED,
    GLS_ANGULAR_SCALE_HALO_WIDTH,
    GLS_ANGULAR_SCALE_HALO_COLOR,
    GLS_ANGULAR_SCALE_USE_SCALABLE_LINES,
    GLS_ANGULAR_SCALE_RADIUS,
    GLS_ANGULAR_SCALE_DATA
};
 
/// \details The GlsAngularScaleData class. Stores information for the appearance of one set of tick marks.
class GlsAngularScaleData
{
protected:
    DistiAttribDict _attribDict; ///< The attribute dictionary for this class' members.
 
public:
    bool         active;       /**< True if this scale is active */
    bool         useLineColor; /**< True if this scale draws with line color */
    unsigned int ticks;        /**< Number of ticks on this scale */
    float        startAngle;   /**< Start angle in degrees */
    float        interval;     /**< Interval between ticks in degrees */
    float        length;       /**< Length of ticks in logical units */
    float        thickness;    /**< Thickness of ticks in logical units */
    GlsColor     color;        /**< Color to draw ticks if line color is not being used*/
 
    GlsAngularScaleData()
        : active( false )
        , useLineColor( false )
        , ticks( 0 )
        , startAngle( 0 )
        , interval( 0 )
        , length( 0 )
        , thickness( 1 )
        , color( 255, 255, 255, 255 )
    {
        InitMetaData();
    }
 
    /// Constructor
    /// \param _active True if this scale is active.
    /// \param _useLineColor True if this scale draws with line color.
    /// \param _ticks Number of ticks on this scale.
    /// \param _startAngle Angle Start angle in degrees.
    /// \param _interval Interval between ticks in degrees.
    /// \param _length Length of ticks in logical units.
    /// \param _thickness Thickness of ticks in logical units.
    /// \param _color Color to draw ticks if line color is not being used.
    GlsAngularScaleData(
        bool            _active,
        bool            _useLineColor,
        unsigned int    _ticks,
        float           _startAngle,
        float           _interval,
        float           _length,
        float           _thickness,
        const GlsColor& _color )
        : active( _active )
        , useLineColor( _useLineColor )
        , ticks( _ticks )
        , startAngle( _startAngle )
        , interval( _interval )
        , length( _length )
        , thickness( _thickness )
        , color( _color )
    {
        InitMetaData();
    }
 
    /// Copy constructor
    /// \param src The object to copy from.
    GlsAngularScaleData( const GlsAngularScaleData& src )
    {
        InitMetaData();
        *this = src;
    }
 
    /// Assignment operator
    /// \param src The object to copy from.
    /// \return the resulting object (this).
    GlsAngularScaleData& operator=( const GlsAngularScaleData& src )
    {
        if( this != &src )
        {
            active       = src.active;
            useLineColor = src.useLineColor;
            ticks        = src.ticks;
            startAngle   = src.startAngle;
            interval     = src.interval;
            length       = src.length;
            thickness    = src.thickness;
            color        = src.color;
 
            _attribDict.CopyCommonValues( src._attribDict );
        }
        return *this;
    }
 
    virtual ~GlsAngularScaleData()
    {
    }
 
    /// Equality operator
    /// \param right The object to compare.
    /// \return Whether or not the objects are equal.
    bool GLSGEN_GLSANGULARSCALE_EXPORT operator==( const GlsAngularScaleData& right ) const;
 
    /// Inequality operator
    /// \param right The object to compare.
    /// \return Whether or not the objects are not equal.
    bool GLSGEN_GLSANGULARSCALE_EXPORT operator!=( const GlsAngularScaleData& right ) const
    {
        return !( this->operator==( right ) );
    }
 
    /// Create DistiAttributes for this object's members.
    void GLSGEN_GLSANGULARSCALE_EXPORT InitMetaData();
 
    /// Writes this to a stream.
    /// \param outstr The stream to write to.
    /// \return The stream in its current state.
    virtual GLSGEN_GLSANGULARSCALE_EXPORT std::ostream& WriteValue( std::ostream& outstr );
 
    /// Reads this from a stream.
    /// \param instr The stream to read from.
    /// \return The stream in its current state.
    virtual GLSGEN_GLSANGULARSCALE_EXPORT std::istream& ReadValue( std::istream& instr );
};
 
#define GLS_ANGULAR_SCALE_MAX 5 ///< The maximum number of unique tick mark types.
 
typedef GlsAngularScaleData GlsAngularScaleDataArray[ GLS_ANGULAR_SCALE_MAX ]; ///< Typedef for one GlsAngularScale worth of scale data.
 
/** Runtime implementation of a GlsAngularScale */
class GlsAngularScale : public GLPolygon
{
    friend class GlsAngularScaleEditor;
 
private:
    GlsAngularScale& operator=( const GlsAngularScale& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsAngularScale( const GlsAngularScale& ) 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.
 
    /** Create a new GlsAngularScale.
      * \param generateInstance  Whether or not to generate an instance name
      * for this inputdevice */
    GLSGEN_GLSANGULARSCALE_EXPORT GlsAngularScale( bool generateInstance = false );
 
    /** The copy constructor for GlsAngularScale
     * 
     * \param that          The GlsAngularScale object that is being copied
     * \param generateNames Whether or not to generate a new instance name
     */
    GLSGEN_GLSANGULARSCALE_EXPORT GlsAngularScale( const GlsAngularScale& that, const bool generateNames );
 
    /** Destructs a GlsAngularScale object */
    virtual GLSGEN_GLSANGULARSCALE_EXPORT ~GlsAngularScale();
 
    /// \return A pointer to a new GlsAngularScale object.
    static GLSGEN_GLSANGULARSCALE_EXPORT DisplayObject* CreateInstance();
 
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void           CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void           CopyGeometry( DisplayObject* srcArg ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GLSANGULARSCALE_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT Vertex* Vertices() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void    GetExtents( float& minx, float& miny, float& minz, float& maxx, float& maxy, float& maxz ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void    GetTransformedExtents( Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void    UpdateBoundingVolume() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void    SetColor( const GlsColor& color ) DISTI_METHOD_OVERRIDE;
 
    /// An alias of SetColor, kept for backward compatibility.
    /// \param color The new color to set.
    DISTI_DEPRECATED( "Use SetColor() instead." )
    inline void SetLineColor( const GlsColor& color ) { SetColor( color ); }
 
#ifndef GLES
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void AntiAlias( bool alias ) DISTI_METHOD_OVERRIDE;
#endif
 
    GLSGEN_GLSANGULARSCALE_EXPORT DisplayObject* handle( DisplayEvent* ev ) DISTI_METHOD_OVERRIDE;
    GLSGEN_GLSANGULARSCALE_EXPORT virtual void   SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
 
    //////////////////////////////////////////////////
    // GlsAngularScale specific operations
    //////////////////////////////////////////////////
 
    /** Initializes data for one of the scales
      * \param index  Zero based index of the scale to set
      * \param data   The data to set
      */
    GLSGEN_GLSANGULARSCALE_EXPORT void SetScale( int index, const GlsAngularScaleData& data );
 
    /** Gets data for one of the scales
      * \param index  Zero based index of the scale to get
      * \param data   The GlsAngularScaleData structure to fill
      */
    GLSGEN_GLSANGULARSCALE_EXPORT void GetScale( int index, GlsAngularScaleData& data );
 
    /** Sets the tick deconfliction state for this scale
      * \param val  Wether or not to enable tick deconfliction
      */
    GLSGEN_GLSANGULARSCALE_EXPORT void DeconflictTicks( const bool& val );
 
    /** Gets the tick deconfliction state for this scale
      * \return Whether or not tick deconfliction is enabled
      */
    GLSGEN_GLSANGULARSCALE_EXPORT bool DeconflictTicks() { return _deconflictTicks; }
 
    /** Gets the halo state for this scale
      * \return Whether or not halo is enabled
      */
    GLSGEN_GLSANGULARSCALE_EXPORT bool HaloEnabled() { return _haloEnabled; }
 
    /** Sets the halo state for this scale
      * \param val  Wether or not to enable halo
      */
    GLSGEN_GLSANGULARSCALE_EXPORT void HaloEnabled( const bool& val );
 
    /** Gets the halo width for this scale
      * \return The halo width for this scale
      */
    GLSGEN_GLSANGULARSCALE_EXPORT float HaloWidth() { return _haloWidth; }
 
    /** Sets the halo width for this scale
      * \param val  New halo width
      */
    GLSGEN_GLSANGULARSCALE_EXPORT void HaloWidth( const float& val );
 
    /** Gets the halo color for this scale
      * \return The halo color for this scale
      */
    GLSGEN_GLSANGULARSCALE_EXPORT GlsColor HaloColor() { return _haloColor; }
 
    /** Sets the halo color for this scale
      * \param val  New halo color
      */
    GLSGEN_GLSANGULARSCALE_EXPORT void HaloColor( const GlsColor& val );
 
#ifndef GLES
    /** Gets the drawing mode for this scale
      * \return The drawing mode for this scale
      */
    GLSGEN_GLSANGULARSCALE_EXPORT bool UseScalableLines() { return _useScalableLines; }
 
    /** Sets the drawing mode for this scale
      * \param val  New drawing mode
      */
    GLSGEN_GLSANGULARSCALE_EXPORT void UseScalableLines( const bool& val );
 
#endif
    /** Gets the radius for this scale
      * \return The radius for this scale
      */
    GLSGEN_GLSANGULARSCALE_EXPORT float Radius()
    {
        return _magnitude[ 0 ];
    }
 
    /** Sets the radius for this scale
      * \param val  New radius
      */
    GLSGEN_GLSANGULARSCALE_EXPORT void Radius( const float& val );
 
#ifdef GLES
    /** Causes the VBO for this object to be recomputed */
    GLSGEN_GLSANGULARSCALE_EXPORT void InvalidateGeometry()
    {
        _geometryRefresh = true;
        InvalidatePainter();
    }
#else
    /** Causes the VBO for this object to be recomputed */
    GLSGEN_GLSANGULARSCALE_EXPORT void InvalidateGeometry()
    {
        _displayList.Invalidate();
        InvalidatePainter();
    }
 
    /// \return A reference to this object's display list.
    GLSGEN_GLSANGULARSCALE_EXPORT GlsDisplayList& DisplayList() { return _displayList; }
#endif
 
protected:
    /** True when the object's vertices need to be recalculated */
    bool _needsRecalculate;
 
    /** Calculates _radii based on_magnitude and _radiiUnit */
    void MagnitudeChanged();
 
    /** Calculates _radiiUnit and _magnitude based on _radii */
    void CalculateRadiiUnit();
 
#ifdef GLES
    GlsQuadListVC_3D _quads; ///< Manages a VBO for drawing the tick marks.
#    ifdef GLES20
    GlsQuadListVC_3D _antiAliasQuads; ///< Manages a VBO for drawing a feathered outline for antialiasing.
#    endif
 
    void BakeVBO(); ///< Updates the VBO(s) when the object changes.
#endif
 
#ifndef GLES
    /// Minimizes calls to glColor when drawing the scale.
    /// \param newColor The new color to set.
    void CurrentColor( const GlsColor& newColor );
 
    /// Minimizes calls to glLineWidth when drawing the scale.
    /// \param newLineWidth The new line width to set.
    void CurrentLineWidth( const float& newLineWidth );
 
    /** Stores the current color.  Used when calculating a new display list so that redundant 
      * glColor calls are not made */
    GlsColor _currentColor;
 
    /** Stores the current line width.  Used when calculating a new display list so that redundant 
      * glLineWidth calls are not made */
    float _currentLineWidth;
 
    /** True if the current color has been set.  Gets reset every time a new display list is
      * recalculated. */
    bool _currentColorSet;
 
    /** True if the current line width has been set.  Gets reset every time a new display list is
      * recalculated. */
    bool _currentLineWidthSet;
 
    /** Stores the scale in a display list for faster drawing */
    GlsDisplayList _displayList;
#endif
 
    /** Recomputes the object's vertices from its radii */
    void RecomputeVertices();
 
    /// Determines if a tick with the given angle should be drawn or not. If a higher priority
    /// scale already has a tick at that level and deconfliction is enabled, then this method
    /// will return false.
    /// \param currentLevel The current tick type being considered for drawing.
    /// \param currentAngle The angle of the proposed tick.
    /// \return True if the tick should be drawn.
    bool TickNeeded( int currentLevel, float currentAngle );
 
    /// Calculates and draws a single scale using the given halo length and thickness
    /// \param i               The index of the scale to draw
    /// \param haloLength      The length of the halo
    /// \param haloThickness   The thickness of the halo
#ifdef GLES
    /// \param color           The color of the scale
    void DrawScale( int i, float haloLength, float haloThickness, GlsColor& color );
#else
    void                                          DrawScale( int i, float haloLength, float haloThickness );
#endif
 
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif
 
#ifndef GLES
    /** Calculates current tick mark locations and performs OpenGL drawing commands */
    virtual void DrawGeometry();
#endif
 
    /** Always equal to _radiiUnit * _magnitude */
    Vector _radii[ 2 ];
 
    /** Unit vectors describing the radii */
    Vector _radiiUnit[ 2 ];
 
    /** Magnitudes of the two radii */
    float _magnitude[ 2 ];
 
    /** The particulars of each scale */
    GlsAngularScaleDataArray _scale;
 
    /** True if duplicated tick marks are removed */
    bool _deconflictTicks;
 
    /** True if haloing is enabled */
    bool _haloEnabled;
 
    /** Width of the halo in logical units */
    float _haloWidth;
 
    /** Color of the halo */
    GlsColor _haloColor;
 
#ifndef GLES
    /** True if scale is drawn with polygon quads instead of lines*/
    bool _useScalableLines;
#endif
};
 
/** Metadata for scale data */
class DistiAttributeConnectionGlsAngularScaleDataArray : public DistiAttributeBase
{
protected:
    GlsAngularScaleDataArray* _attribPtr; ///< Observer of the underlying storage for the property.
    unsigned int              _arraySize; ///< Always GLS_ANGULAR_SCALE_MAX.
 
public:
    /// Constructor
    /// \param callback The callback method to call when this property changes.
    /// \param name The name of this attribute.
    /// \param attribPtr A pointer to the underlying storage for this property.
    /// \param arraySize Always GLS_ANGULAR_SCALE_MAX.
    DistiAttributeConnectionGlsAngularScaleDataArray( CallbackMethodCallerBase* callback, const AttributeName& name, GlsAngularScaleDataArray* attribPtr, int arraySize )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
        , _arraySize( arraySize )
    {
    }
 
    virtual GLSGEN_GLSANGULARSCALE_EXPORT ~DistiAttributeConnectionGlsAngularScaleDataArray();
 
    virtual GLSGEN_GLSANGULARSCALE_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSANGULARSCALE_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSANGULARSCALE_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
 
} // namespace disti
 
#endif