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

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

class GlsAngularScaleData
{
protected:
    DistiAttribDict _attribDict;

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(void) :
        active(false),
        useLineColor(false),
        ticks(0),
        startAngle(0),
        interval(0),
        length(0),
        thickness(1),
        color(255,255,255,255)
    {
        InitMetaData();
    }

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

    GlsAngularScaleData(const GlsAngularScaleData& src)
    {
        *this = src;
    }

    ~GlsAngularScaleData(void)
    {
    }

    bool GLSGEN_GLSANGULARSCALE_EXPORT operator==( const GlsAngularScaleData& right ) const;

    bool GLSGEN_GLSANGULARSCALE_EXPORT operator!=( const GlsAngularScaleData& right ) const
    {
        return !( this->operator==( right ) );
    }

    void GLSGEN_GLSANGULARSCALE_EXPORT InitMetaData(void);

    // Writes this to a stream
    virtual GLSGEN_GLSANGULARSCALE_EXPORT std::ostream & WriteValue(std::ostream &outstr); 

    // Reads this from a stream
    virtual GLSGEN_GLSANGULARSCALE_EXPORT std::istream & ReadValue(std::istream &instr);
} ;

#define GLS_ANGULAR_SCALE_MAX 5

typedef GlsAngularScaleData GlsAngularScaleDataArray[GLS_ANGULAR_SCALE_MAX];

/** 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:   
    typedef GLPolygon _BaseClass;

    /** 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();

    static GLSGEN_GLSANGULARSCALE_EXPORT DisplayObject* CreateInstance();

    virtual GLSGEN_GLSANGULARSCALE_EXPORT void SetAvailableAttributes(unsigned int value);

    virtual GLSGEN_GLSANGULARSCALE_EXPORT DisplayObject* CloneObject(bool generateNames = false);

    virtual GLSGEN_GLSANGULARSCALE_EXPORT void CopyProperties(DisplayObject *src);

    virtual GLSGEN_GLSANGULARSCALE_EXPORT void CopyGeometry(DisplayObject *srcArg);

#ifndef GLES
    virtual GLSGEN_GLSANGULARSCALE_EXPORT InterfaceListType* GetCppInterfaceDescription(InterfaceListType* addToThisList= NULL );
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void GetCppInterfaceDescriptionFree(InterfaceListType* array);
#endif
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices,Culler &culler );
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void Draw(void);

    virtual GLSGEN_GLSANGULARSCALE_EXPORT void Scale(float px, float py, float pz, Vertex *anchor, int handleBar);
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void Rotate(const Vector &orig,float angle,const Vector &axis);
    virtual GLSGEN_GLSANGULARSCALE_EXPORT bool Hit(float x,float y,float z,float scale, const Vector& directionVector,Vector *collisionPoint);

    virtual GLSGEN_GLSANGULARSCALE_EXPORT Vertex* Vertices();
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void GetExtents(float &minx,float &miny,float &minz, float &maxx,float &maxy,float &maxz);
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void GetTransformedExtents(Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax);
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void UpdateBoundingVolume(void);

    virtual GLSGEN_GLSANGULARSCALE_EXPORT void SetColor(const glsColor& color);
    inline void SetLineColor(const glsColor& color) { SetColor(color); }

#ifndef GLES
    virtual GLSGEN_GLSANGULARSCALE_EXPORT void AntiAlias(bool alias);
#endif

    DisplayObject* handle(DisplayEvent *ev);

    virtual void SetValue(int spec,va_list &args);

    //////////////////////////////////////////////////
    // 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(void) { return _deconflictTicks; }


    /** Gets the halo state for this scale
      * \return Whether or not halo is enabled
      */
    GLSGEN_GLSANGULARSCALE_EXPORT bool HaloEnabled(void) { 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(void) { 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(void) { 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(void) { 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(void) 
    {
        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(void) { _geometryRefresh = true; }
#else
    /** Causes the VBO for this object to be recomputed */
    GLSGEN_GLSANGULARSCALE_EXPORT void InvalidateGeometry(void) { _displayList.Invalidate(); }

    /** Returns a reference to this object's display list */
    GLSGEN_GLSANGULARSCALE_EXPORT GlsDisplayList &DisplayList(void) { 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(void);

    /** Calculates _radiiUnit and _magnitude based on _radii */
    void CalculateRadiiUnit(void);

#ifdef GLES
    /** Manages a VBO for drawing the tick marks */
    GlsQuadListVC_3D _quads;

    /** Updates the VBO when the object changes */
    void BakeVBO();
#endif

#ifndef GLES
    /** Minimizes calls to glColor when drawing the scale */
    void CurrentColor(const glsColor &newColor); 

    /** Minimizes calls to glLineWidth when drawing the scale */
    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(void);

    /** 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 */
    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);
#endif
    
#ifndef GLES
    /** Calculates current tick mark locations and performs OpenGL drawing commands */
    virtual void DrawGeometry(void);
#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;
    unsigned int          _arraySize;

public:

    DistiAttributeConnectionGlsAngularScaleDataArray(CallbackMethodCallerBase* callback, const AttributeName &name, GlsAngularScaleDataArray *attribPtr,int arraySize) :
        DistiAttributeBase(callback,name,false),
        _attribPtr(attribPtr),
        _arraySize(arraySize)
    {
    }

    virtual ~DistiAttributeConnectionGlsAngularScaleDataArray();
    virtual bool OkToWrite() const;
    virtual std::ostream & WriteValue(std::ostream &outstr);
    virtual std::istream & ReadValue(std::istream &instr);
  
};


} // namespace disti

#endif