gls_linear_float_controller.h

Go to the documentation of this file.

/*! \file
 \brief Implementation of GlsLinearFloatController.
 
 \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_FLOAT_CONTROLLER_H_INCLUDED
#define GLS_LINEAR_FLOAT_CONTROLLER_H_INCLUDED
 
#include "display.h"
#include "gls_cpp_lang_support.h"
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSADVANCEDMESH ) || defined( GLSGEN_IMPORT_GLSADVANCEDMESH ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSADVANCEDMESH ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GlsLinearFloatController_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GlsLinearFloatController_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GlsLinearFloatController_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_advanced_mesh"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
/// \details IFloatController allows working with all float controllers through a common interface.
class IFloatController
{
public:
    /** Destructor */
    virtual ~IFloatController() {}
 
    /// Get the output value for a given input.
    /// \param input The given input value.
    /// \return The output value for the given input.
    virtual float GetOutputForInput( float input ) = 0;
 
    /** The caller may use this method to determine the valid input range for the animation
     * Note: Some controllers may always return -FLT_MAX
     * \returns The first input value in the animation */
    virtual float GetFirstInputValue() = 0;
 
    /** The caller may use this method to determine the valid input range for the animation
     * Note: Some controllers may always return FLT_MAX
     * \returns The last input value in the animation */
    virtual float GetLastInputValue() = 0;
};
 
/// \details The GlsLinearFloatController class. Interpolates incoming values based on its stored keyframes.
class GlsLinearFloatController : public DisplayObject
    , public IFloatController
{
    friend class GlsLinearFloatControllerEditor;
 
private:
    GlsLinearFloatController& operator=( const GlsLinearFloatController& );
    GlsLinearFloatController( const GlsLinearFloatController& );
 
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DisplayObject _BaseClass; ///< Deprecated typedef for the base class.
    typedef DisplayObject BaseClass;  ///< Typedef for the base class.
 
    /** Create a new GlsLinearFloatController
      * \param generateInstanceName  Whether or not to generate an instance name */
    GLSGEN_GlsLinearFloatController_EXPORT GlsLinearFloatController( bool generateInstanceName = false );
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name.
    GLSGEN_GlsLinearFloatController_EXPORT GlsLinearFloatController( const GlsLinearFloatController& that, const bool generateNames );
 
    virtual GLSGEN_GlsLinearFloatController_EXPORT ~GlsLinearFloatController();
 
    /// \return A pointer to a new GlsLinearFloatController object.
    static GLSGEN_GlsLinearFloatController_EXPORT DisplayObject* CreateInstance();
 
    // DisplayObject methods
 
    virtual GLSGEN_GlsLinearFloatController_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsLinearFloatController_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsLinearFloatController_EXPORT void           CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GlsLinearFloatController_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsLinearFloatController_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
    virtual GLSGEN_GlsLinearFloatController_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsLinearFloatController_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsLinearFloatController_EXPORT DisplayObject* handle( DisplayEvent* ev ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsLinearFloatController_EXPORT bool           Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
 
    // IFloatController methods
 
    virtual GLSGEN_GlsLinearFloatController_EXPORT float GetOutputForInput( float input ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsLinearFloatController_EXPORT float GetFirstInputValue() DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsLinearFloatController_EXPORT float GetLastInputValue() DISTI_METHOD_OVERRIDE;
 
    // GlsLinearFloatController methods
 
    /// \details The KeyData class. Contains a single keyframe of animation.
    class KeyData
    {
        float _input;  ///< The input (key) value.
        float _output; ///< The output value.
 
    public:
        KeyData()
            : _input( 0 )
            , _output( 0 )
        {}
 
        /// Sets the input (key) value.
        /// \param value The new value to set.
        inline void SetInputValue( float value ) { _input = value; }
 
        /// \return The input (key) value.
        inline float GetInputValue() const { return _input; }
 
        /// Set the output value.
        /// \param value The new value to set.
        inline void SetOutputValue( float value ) { _output = value; }
 
        /// \return The output value.
        inline float GetOutputValue() const { return _output; }
    };
 
    typedef DynamicArray<KeyData> KeyArrayType; ///< Typedef for a list of animation keys.
 
    /// \return The KeyArray associated with this object.  Use this array to modify the keys that make up the animation.
    inline KeyArrayType& KeyArray() { return _keyArray; }
 
    /// Iterates through the path segments and returns the first one found that contains the given value.
    /// \param value The value to search for.
    /// \param index1 Returns the index of the state at the start of the segment or -1 if no segments are found.
    /// \param index2 Returns the index of the state at the end the segment or -1 if no segments are found.
    /// Special cases:
    ///     value is before start of the path: index1 == index2 == 0
    ///     value is past the end of the path: index1 == index2 == (KeyArray().Count()-1)
    GLSGEN_GlsLinearFloatController_EXPORT void FindFirstPathSegmentContainingValue( float value, int* index1, int* index2 );
 
    /// Initialize the key array.
    /// Used by code generator.
    /// \param numKeys The number of keys.
    /// \param keyPairArray Array of numKey*2 values that are used to initialize the keys.
    GLSGEN_GlsLinearFloatController_EXPORT void InitializeKeys( unsigned int numKeys, const float* keyPairArray );
 
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLSGEN_GlsLinearFloatController_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif
 
protected:
    KeyArrayType _keyArray; ///< The list of key values for interpolation.
};
 
/// Stream out operator
/// \param outstr The stream to write to.
/// \param key The value to write to the stream.
/// \return The stream in its current state.
GLSGEN_GlsLinearFloatController_EXPORT std::ostream& operator<<( std::ostream& outstr, const GlsLinearFloatController::KeyData& key );
 
/// Stream in operator
/// \param instr The stream to read from.
/// \param key The returned value read from the stream.
/// \return The stream in its current state.
GLSGEN_GlsLinearFloatController_EXPORT std::istream& operator>>( std::istream& instr, GlsLinearFloatController::KeyData& key );
 
} // namespace disti
 
#endif