gls_linear_scale.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsLinearScale class.

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

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

typedef enum
{
    GLS_TICK_ANCHOR_TOP,
    GLS_TICK_ANCHOR_BOTTOM,
    GLS_TICK_ANCHOR_CENTER
} GlsTickAnchor;

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

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

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

    ~GlsLinearScaleData(void)
    {
    }

    bool GLSGEN_GLSLINEARSCALE_EXPORT operator==( const GlsLinearScaleData& right ) const;

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

    void GLSGEN_GLSLINEARSCALE_EXPORT InitMetaData(void);

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

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

#define GLS_LINEAR_SCALE_MAX 5

typedef GlsLinearScaleData GlsLinearScaleDataArray[GLS_LINEAR_SCALE_MAX];

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

    /** Create a new GlsLinearScale.
      * \param generateInstance  Whether or not to generate an instance name
      * for this inputdevice */
    GLSGEN_GLSLINEARSCALE_EXPORT GlsLinearScale(bool generateInstance=false);

    GLSGEN_GLSLINEARSCALE_EXPORT GlsLinearScale( const GlsLinearScale& that, const bool generateNames );

    /** Destructs a GlsLinearScale object */
    virtual GLSGEN_GLSLINEARSCALE_EXPORT ~GlsLinearScale();

    static GLSGEN_GLSLINEARSCALE_EXPORT DisplayObject* CreateInstance();

    virtual GLSGEN_GLSLINEARSCALE_EXPORT void SetAvailableAttributes(unsigned int value);

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

    virtual GLSGEN_GLSLINEARSCALE_EXPORT void CopyProperties(DisplayObject *src);

    virtual GLSGEN_GLSLINEARSCALE_EXPORT void CopyGeometry(DisplayObject *srcArg);

#ifndef GLES
    virtual GLSGEN_GLSLINEARSCALE_EXPORT InterfaceListType* GetCppInterfaceDescription(InterfaceListType* addToThisList= NULL );
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void GetCppInterfaceDescriptionFree(InterfaceListType* array);
#endif

    virtual GLSGEN_GLSLINEARSCALE_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices,Culler &culler );
    virtual GLSGEN_GLSLINEARSCALE_EXPORT void Draw(void);

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

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

    virtual GLSGEN_GLSLINEARSCALE_EXPORT void SetColor(const glsColor& color);

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


    /** Gets the halo state for this scale
      * \return Whether or not halo is enabled
      */
    GLSGEN_GLSLINEARSCALE_EXPORT bool HaloEnabled(void) { 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(void) { 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(void) { 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(void) { 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(void) { _geometryRefresh = true; }
#endif

#ifndef GLES
    /** Gets the drawing mode for this scale
      * \return The drawing mode for this scale
      */
    GLSGEN_GLSLINEARSCALE_EXPORT bool UseScalableLines(void) { 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( void ) { _displayList.Invalidate(); }

    /** Returns a reference to this object's display list */
    GLSGEN_GLSLINEARSCALE_EXPORT GlsDisplayList& DisplayList( void ) { return _displayList; }
#endif

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

    /** Updates the VBO when the object changes */
    void BakeVBO();
#else
    /** 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);

    /** Recomputes the object's vertices and its radii */
    void UpdateScaleData(void);

    /** 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 */
    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 void SetFromGloData(GlsGloFileAttribute &data);
#endif

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

public:

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

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

} // namespace disti

#endif