gls_odometer.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsOdometer 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 _GLSODOMETER_H
#define _GLSODOMETER_H
 
#include "gls_cpp_lang_support.h"
#include "group.h"
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSODOMETER ) || defined( GLSGEN_IMPORT_GLSODOMETER ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSODOMETER ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GLSODOMETER_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSODOMETER_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSODOMETER_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_odometer"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
enum
{
    GLS_GLSODOMETER_VALUE = GLS_LAST_INITIALIZER + 1,
    GLS_GLSODOMETER_MIN_VALUE,
    GLS_GLSODOMETER_MAX_VALUE,
    GLS_GLSODOMETER_BASE_SYSTEM,
    GLS_GLSODOMETER_BEHAVIOR_TYPE,
    GLS_GLSODOMETER_GEOMETRY_TYPE,
    GLS_GLSODOMETER_TEXTURE_SCALE,
    GLS_GLSODOMETER_DEGREES_PER_DIGIT
};
 
/** Runtime implementation of a GlsOdometer */
class GlsOdometer : public Group
{
    friend class GlsOdometerEditor;
 
private:
    GlsOdometer& operator=( const GlsOdometer& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsOdometer( const GlsOdometer& ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef Group _BaseClass; ///< Deprecated typedef for the base class.
    typedef Group BaseClass;  ///< Typedef for the base class.
 
    /// Constructor
    /// \param generateInstance Whether or not to generate an instance name for this object.
    GLSGEN_GLSODOMETER_EXPORT GlsOdometer( bool generateInstance = false );
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name for this object.
    GLSGEN_GLSODOMETER_EXPORT GlsOdometer( const GlsOdometer& that, const bool generateNames );
 
    /** Destructs a GlsOdometer object */
    virtual GLSGEN_GLSODOMETER_EXPORT ~GlsOdometer();
 
    /// \return A pointer to a new GlsOdometer object.
    static GLSGEN_GLSODOMETER_EXPORT DisplayObject* CreateInstance();
 
    virtual GLSGEN_GLSODOMETER_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSODOMETER_EXPORT void CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSODOMETER_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GLSODOMETER_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSODOMETER_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSODOMETER_EXPORT DisplayObject* handle( DisplayEvent* ev ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSODOMETER_EXPORT void           PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSODOMETER_EXPORT void           Draw() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSODOMETER_EXPORT void           SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
 
    //////////////////////////////////////////////////
    // GlsOdometer specific declarations
    //////////////////////////////////////////////////
 
    /// \details The GlsOdometerBehaviorType enumeration. Controls the scroll behavior of the odometer texture.
    typedef enum
    {
        BEHAVIOR_ANALOG = 0,
        BEHAVIOR_DIGITAL
    } GlsOdometerBehaviorType;
 
    /// \details The GlsOdometerGeometryType enumeration. Controls the whether the odometer should scroll a texture, or rotate geometry.
    typedef enum
    {
        GEOMETRY_2D = 0,
        GEOMETRY_3D
    } GlsOdometerGeometryType;
 
    /// Set the maximum displayable value.
    /// \param value The new maximum value to set.
    GLSGEN_GLSODOMETER_EXPORT void MaxValue( const float& value );
 
    /// \return The maximum displayable value.
    virtual GLSGEN_GLSODOMETER_EXPORT float MaxValue();
 
    /// Set the minimum displayable value.
    /// \param value The new minimum value to set.
    GLSGEN_GLSODOMETER_EXPORT void MinValue( const float& value );
 
    /// \return The minimum displayable value.
    virtual GLSGEN_GLSODOMETER_EXPORT float MinValue();
 
    /// Set the current value to be displayed by the odometer.
    /// This value is limited by MaxValue() and MinValue().
    /// \param value The new value to set.
    GLSGEN_GLSODOMETER_EXPORT void Value( const float& value );
 
    /// \return The current value of the odometer.
    virtual GLSGEN_GLSODOMETER_EXPORT float Value();
 
    /// Set the base number system for this odometer.
    /// The default is base 10.
    /// \param value The new base system to set.
    virtual GLSGEN_GLSODOMETER_EXPORT void BaseSystem( const int& value );
 
    /// \return The base number system for this odometer.
    virtual GLSGEN_GLSODOMETER_EXPORT int BaseSystem();
 
    /// Set the BehaviorType controls the "Rollover" behavior of the odometer.
    /// BEHAVIOR_ANALOG - Wheels will roll between numbers based on the RolloverThreshold
    /// BEHAVIOR_DIGITAL - Wheels will display only whole numbers.
    /// \param value The new rollover behavior to set.
    GLSGEN_GLSODOMETER_EXPORT void BehaviorType( const GlsOdometerBehaviorType value );
 
    /// \return The BehaviorType controls the "Rollover" behavior of the odometer.
    virtual GLSGEN_GLSODOMETER_EXPORT GlsOdometerBehaviorType BehaviorType();
 
    /// Set the GeometryType controls the method used to "move" the wheels.
    /// GEOMETRY_2D - Texture is translated on the object based on the TextureScale.
    /// GEOMETRY_3D - The wheels are rotated about the Y-AXIS of the DCS based on the value of DegreesPerDigit.
    /// \param value The new "movement" behavior to set.
    GLSGEN_GLSODOMETER_EXPORT void GeometryType( const GlsOdometerGeometryType value );
 
    /// \return The GeometryType method used to "move" the wheels.
    virtual GLSGEN_GLSODOMETER_EXPORT GlsOdometerGeometryType GeometryType();
 
    /// Set the TextureScale which is the amount that the texture should move for each digit.
    /// The formula to determine this is: (Pixels per digit)/(Texture height).
    /// This value is only used when GeometryType == GEOMETRY_2D.
    /// \param value The new texture movement amount to set.
    GLSGEN_GLSODOMETER_EXPORT void TextureScale( const float& value );
 
    /// \return The TextureScale, the amount that the texture should move for each digit.
    virtual GLSGEN_GLSODOMETER_EXPORT float TextureScale();
 
    /// Set the DegreesPerDigit which is the number of degrees the wheels should be rotated for each digit.
    /// This value is only used when GeometryType == GEOMETRY_3D.
    /// \param value The new geometry rotation amount to set.
    GLSGEN_GLSODOMETER_EXPORT void DegreesPerDigit( const float& value );
 
    /// \return The DegreesPerDigit, the number of degrees the wheels should be rotated for each digit.
    virtual GLSGEN_GLSODOMETER_EXPORT float DegreesPerDigit();
 
    /// \return The order of magnitude (number of digits) the odometer can have.
    virtual GLSGEN_GLSODOMETER_EXPORT int OrderOfMagnitude() const;
 
    /// \return The amount required to make the first digit roll over by one.
    virtual GLSGEN_GLSODOMETER_EXPORT float RolloverThreshold() const;
 
protected:
    int   _orderOfMagnitude;  ///< The number of digits (zeroes) the odometer can have.
    float _textureScale;      ///< The amount in texture coordinates to move for each digit. GeometryType == GEOMETRY_2D
    float _degreesPerDigit;   ///< The amount to rotate the geometry for each digit. GeometryType == GEOMETRY_3D
    float _rolloverThreshold; ///< The amount required to make the first digit roll over by one.
 
    float                   _minValue;     ///< The minimum value that can be represented on the wheels.
    float                   _maxValue;     ///< The maximum value that can be represented on the wheels.
    int                     _baseSystem;   ///< The base system represented, e.g. base 10.
    float                   _currentValue; ///< The current value displayed on the wheels.
    GlsOdometerBehaviorType _behavior;     ///< The "rollover" behavior in use.
    GlsOdometerGeometryType _geometry;     ///< The "movement" behavior in use.
 
    /// \details The TexturePoints class. Used for storing the initial texture position of the GlsOdometer.
    class TexturePoints
    {
    public:
        Vector v1; ///< The bottom left corner.
        Vector v2; ///< The bottom right corner.
        Vector v3; ///< The top right corner.
        Vector v4; ///< The top left corner.
    };
 
    DynamicArray<TexturePoints> _startLoc;        ///< A list of start texture locations, one for each wheel.
    bool                        _textureLocSaved; ///< True denotes that the texture locations have been saved off.
 
    /// Sets the current order of magnitude (number of zeroes)
    /// \note Not normally called by users.
    /// \param value The new magnitude value to set.
    void OrderOfMagnitude( const int& value );
 
    /// Sets the rollover threshold (amount needed to move the first wheel by one)
    /// \note Not normally called by users.
    /// \param value The new rollover value to set.
    void RolloverThreshold( const float& value );
 
    /// Helper function that recalculates _orderOfMagnitude.
    /// \note Not normally called by users.
    void CalculateOrderOfMagnitude();
 
    /// Helper function that recalculates _rolloverThreshold.
    /// \note Not normally called by users.
    void CalculateRolloverThreshold();
 
    /// Sets the current texture coordinates as the zero position for the wheels.
    /// \note Not normally called by users.
    void SaveTextureLoc();
 
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLS_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif
};
 
} // namespace disti
 
#endif