gls_linear_scale.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsLinearScale 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.
 
*/
#ifndef _GLS_LINEAR_SCALE_H
#define _GLS_LINEAR_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_GLSLINEARSCALE ) || defined( GLSGEN_IMPORT_GLSLINEARSCALE ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSLINEARSCALE ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GLSLINEARSCALE_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSLINEARSCALE_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSLINEARSCALE_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_linear_scale"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
// SetValue enumerations
enum
{
    GLS_LINEAR_SCALE_FIRST_VALUE = GLS_LAST_INITIALIZER + 1,
    GLS_LINEAR_SCALE_RADII,
    GLS_LINEAR_SCALE_DECONFLICT_TICKS,
    GLS_LINEAR_SCALE_HALO_ENABLED,
    GLS_LINEAR_SCALE_HALO_WIDTH,
    GLS_LINEAR_SCALE_HALO_COLOR,
    GLS_LINEAR_SCALE_TICK_ANCHOR,
    GLS_LINEAR_SCALE_USE_SCALABLE_LINES,
    GLS_LINEAR_SCALE_DATA
};
 
/// Tick anchor behavior
typedef enum
{
    GLS_TICK_ANCHOR_TOP,
    GLS_TICK_ANCHOR_BOTTOM,
    GLS_TICK_ANCHOR_CENTER
} GlsTickAnchor;
 
/// \details The GlsLinearScaleData class. Stores information for the appearance of one set of tick marks.
class GlsLinearScaleData
{
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        startingOffset; ///< Start offset in logical units.
    float        interval;       ///< Interval between ticks in logical units.
    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.
 
    GlsLinearScaleData()
        : active( false )
        , useLineColor( false )
        , ticks( 0 )
        , startingOffset( 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 _startingOffset Start offset in logical units.
    /// \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.
    GlsLinearScaleData(
        bool            _active,
        bool            _useLineColor,
        unsigned int    _ticks,
        float           _startingOffset,
        float           _interval,
        float           _length,
        float           _thickness,
        const GlsColor& _color )
        : active( _active )
        , useLineColor( _useLineColor )
        , ticks( _ticks )
        , startingOffset( _startingOffset )
        , interval( _interval )
        , length( _length )
        , thickness( _thickness )
        , color( _color )
    {
        InitMetaData();
    }
 
    /// Copy constructor
    /// \param src The object to copy from.
    GlsLinearScaleData( const GlsLinearScaleData& src )
    {
        InitMetaData();
        *this = src;
    }
 
    /// Assignment operator
    /// \param src The object to copy from.
    /// \return The resulting object (this).
    GlsLinearScaleData& operator=( const GlsLinearScaleData& src )
    {
        if( this != &src )
        {
            active         = src.active;
            useLineColor   = src.useLineColor;
            ticks          = src.ticks;
            startingOffset = src.startingOffset;
            interval       = src.interval;
            length         = src.length;
            thickness      = src.thickness;
            color          = src.color;
 
            _attribDict.CopyCommonValues( src._attribDict );
        }
        return *this;
    }
 
    /// Equality operator
    /// \param right The object to compare.
    /// \return Whether or not the objects are equal.
    bool GLSGEN_GLSLINEARSCALE_EXPORT operator==( const GlsLinearScaleData& right ) const;
 
    /// Inequality operator
    /// \param right The object to compare.
    /// \return Whether or not the objects are not equal.
    bool GLSGEN_GLSLINEARSCALE_EXPORT operator!=( const GlsLinearScaleData& right ) const
    {
        return !( this->operator==( right ) );
    }
 
    /// Create DistiAttributes for this object's members.
    void GLSGEN_GLSLINEARSCALE_EXPORT InitMetaData();
 
    /// Writes this to a stream.
    /// \param outstr The stream to write to.
    /// \return The stream in its current state.
    GLSGEN_GLSLINEARSCALE_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.
    GLSGEN_GLSLINEARSCALE_EXPORT std::istream& ReadValue( std::istream& instr );
};
 
#define GLS_LINEAR_SCALE_MAX 5 ///< The maximum number of unique tick mark types.
 
typedef GlsLinearScaleData GlsLinearScaleDataArray[ GLS_LINEAR_SCALE_MAX ]; ///< Typedef for one GlsLinearScale worth of scale data.
 
#ifdef GLES
class GlsGloFileAttribute;
#endif
 
/** Runtime implementation of a GlsLinearScale */
class GlsLinearScale : public GLPolygon
{
    friend class GlsLinearScaleEditor;
 
private:
    GlsLinearScale& operator=( const GlsLinearScale& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsLinearScale( const GlsLinearScale& ) 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 GlsLinearScale.
      * \param generateInstance  Whether or not to generate an instance name
      * for this inputdevice */
    GLSGEN_GLSLINEARSCALE_EXPORT GlsLinearScale( bool generateInstance = false );
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name.
    GLSGEN_GLSLINEARSCALE_EXPORT GlsLinearScale( const GlsLinearScale& that, const bool generateNames );
 
    /** Destructs a GlsLinearScale object */
    virtual GLSGEN_GLSLINEARSCALE_EXPORT ~GlsLinearScale();
 
    /// \return A pointer to a new GlsLinearScale object.
    static GLSGEN_GLSLINEARSCALE_EXPORT DisplayObject* CreateInstance();
 
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void           CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void           CopyGeometry( DisplayObject* srcArg ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GLSLINEARSCALE_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void SetColor( const GlsColor& color ) DISTI_METHOD_OVERRIDE;
 
    //////////////////////////////////////////////////
    // GlsLinearScale 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_GLSLINEARSCALE_EXPORT void SetScale( int index, const GlsLinearScaleData& data );
 
    /** Gets the data for one of the scales
      * \param index  Zero based index of the scale to get
      * \param data   The GlsLinearScaleData structure to fill
      */
    GLSGEN_GLSLINEARSCALE_EXPORT void GetScale( int index, GlsLinearScaleData& data );
 
    /** Sets the tick deconfliction state for this scale
      * \param val  Wether or not to enable tick deconfliction
      */
    GLSGEN_GLSLINEARSCALE_EXPORT void DeconflictTicks( const bool& val );
 
    /** Gets the tick deconfliction state for this scale
      * \return Whether or not tick deconfliction is enabled
      */
    GLSGEN_GLSLINEARSCALE_EXPORT bool DeconflictTicks() { return _deconflictTicks; }
 
    /** Gets the halo state for this scale
      * \return Whether or not halo is enabled
      */
    GLSGEN_GLSLINEARSCALE_EXPORT bool HaloEnabled() { return _haloEnabled; }
 
    /** Sets the halo state for this scale
      * \param val  Wether or not to enable halo
      */
    GLSGEN_GLSLINEARSCALE_EXPORT void HaloEnabled( const bool& val );
 
    /** Gets the halo width for this scale
      * \return The halo width for this scale
      */
    GLSGEN_GLSLINEARSCALE_EXPORT float HaloWidth() { return _haloWidth; }
 
    /** Sets the halo width for this scale
      * \param val  New halo width
      */
    GLSGEN_GLSLINEARSCALE_EXPORT void HaloWidth( const float& val );
 
    /** Gets the halo color for this scale
      * \return The halo color for this scale
      */
    GLSGEN_GLSLINEARSCALE_EXPORT GlsColor HaloColor() { return _haloColor; }
 
    /** Sets the halo color for this scale
      * \param val  New halo color
      */
    GLSGEN_GLSLINEARSCALE_EXPORT void HaloColor( const GlsColor& val );
 
    /** Gets the tick anchor for this scale
      * \return The tick anchor for this scale
      */
    GLSGEN_GLSLINEARSCALE_EXPORT GlsTickAnchor TickAnchor() { return _tickAnchor; }
 
    /** Sets the tick anchor for this scale
      * \param val  New tick anchor
      */
    GLSGEN_GLSLINEARSCALE_EXPORT void TickAnchor( const GlsTickAnchor val );
 
#ifdef GLES
    /** Causes the VBO for this object to be recomputed */
    GLSGEN_GLSLINEARSCALE_EXPORT void InvalidateGeometry()
    {
        _geometryRefresh = true;
        InvalidatePainter();
    }
#endif
 
#ifndef GLES
    /** Gets the drawing mode for this scale
      * \return The drawing mode for this scale
      */
    GLSGEN_GLSLINEARSCALE_EXPORT bool UseScalableLines() { return _useScalableLines; }
 
    /** Sets the drawing mode for this scale
      * \param val  New drawing mode
      */
    GLSGEN_GLSLINEARSCALE_EXPORT void UseScalableLines( const bool& val );
 
    /** Causes the display list for this object to be recomputed */
    GLSGEN_GLSLINEARSCALE_EXPORT void InvalidateGeometry()
    {
        _displayList.Invalidate();
        InvalidatePainter();
    }
 
    /// \return A reference to this object's display list.
    GLSGEN_GLSLINEARSCALE_EXPORT GlsDisplayList& DisplayList() { return _displayList; }
#endif
 
protected:
#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.
#else
    /// 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();
 
    /** Recomputes the object's vertices and its radii */
    void UpdateScaleData();
 
    /// Determines if a tick with the given offset 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 currentOffset The offset of the proposed tick.
    /// \return True if the tick should be drawn.
    bool TickNeeded( int currentLevel, float currentOffset );
 
#ifdef GLES
    /** 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
      * \param color           The color of the scale
      */
    void DrawScale( int i, float haloLength, float haloThickness, GlsColor& color );
#else
    /** 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
      */
    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_GLSLINEARSCALE_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
 
    /** Two radius vectors that are used to define the orientation of the scale */
    Vector _radii[ 2 ];
 
    /** Normalized radius vectors, cached because they are needed often */
    Vector _radiiNormalized[ 2 ];
 
    /** The particulars of each scale */
    GlsLinearScaleDataArray _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;
 
    /** Anchor to determine where ticks will draw */
    GlsTickAnchor _tickAnchor;
 
#ifndef GLES
    /** True if scale is drawn with polygon quads instead of lines*/
    bool _useScalableLines;
#endif
};
 
/** Metadata for scale data */
class DistiAttributeConnectionGlsLinearScaleDataArray : public DistiAttributeBase
{
protected:
    GlsLinearScaleDataArray* _attribPtr; ///< Observer of the underlying storage for the property.
    unsigned int             _arraySize; ///< Always GLS_LINEAR_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_LINEAR_SCALE_MAX.
    DistiAttributeConnectionGlsLinearScaleDataArray( CallbackMethodCallerBase* callback, const AttributeName& name, GlsLinearScaleDataArray* attribPtr, int arraySize )
        : DistiAttributeBase( callback, name, false )
        , _attribPtr( attribPtr )
        , _arraySize( arraySize )
    {
    }
 
    virtual GLSGEN_GLSLINEARSCALE_EXPORT ~DistiAttributeConnectionGlsLinearScaleDataArray();
 
    virtual GLSGEN_GLSLINEARSCALE_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSLINEARSCALE_EXPORT std::ostream& WriteValue( std::ostream& outstr ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSLINEARSCALE_EXPORT std::istream& ReadValue( std::istream& instr ) DISTI_METHOD_OVERRIDE;
};
 
} // namespace disti
 
#endif