D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spMathInterpolator.hpp

Go to the documentation of this file.

/*
 * Interpolator header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_MATH_INTERPOLATOR_H__
#define __SP_MATH_INTERPOLATOR_H__


#include "Base/spMath.hpp"
#include "Base/spTimer.hpp"


namespace sp
{
namespace math
{


class Interpolator
{
    
    public:
        
        virtual ~Interpolator()
        {
        }
        
        virtual void update() = 0;
        
        virtual bool playing() const = 0;
        
    protected:
        
        Interpolator()
        {
        }
        
};


namespace InterpolatorManager
{

SP_EXPORT void add(Interpolator* Interp);

SP_EXPORT void remove(Interpolator* Interp);

SP_EXPORT void update();

} // /namespace InterpolatorManager


template <typename T, typename I, T Func(const T&, const T&, const I&)>
    class FunctionalInterpolator : public Interpolator
{
    
    public:
        
        FunctionalInterpolator(const T &Min = T(0), const T &Max = T(1)) :
            Min_        (Min    ),
            Max_        (Max    ),
            State_      (I(0)   ),
            Speed_      (I(0)   ),
            Playing_    (false  ),
            Finished_   (false  )
        {
        }
        ~FunctionalInterpolator()
        {
            InterpolatorManager::remove(this);
        }
        
        /* === Functions === */
        
        void play(const I &Speed)
        {
            Playing_    = true;
            Finished_   = false;
            Speed_      = Speed;
            State_      = I(0);
            
            InterpolatorManager::add(this);
        }
        
        void play(u64 Duration)
        {
            play(static_cast<I>(1000.0 / (io::Timer::getFPS() * Duration)));
        }
        
        void stop(bool Reset = false)
        {
            Playing_ = false;
            if (Reset)
                State_ = I(0);
        }
        
        void update()
        {
            if (Playing_)
            {
                State_ += Speed_;
                
                if (State_ >= I(1))
                {
                    State_      = I(1);
                    Finished_   = true;
                    
                    stop();
                }
            }
        }
        
        T get() const
        {
            return Func(Min_, Max_, State_);
        }
        
        bool playing() const
        {
            return Playing_;
        }
        
        /* === Inline functions === */
        
        inline bool finished() const
        {
            return Finished_;
        }
        
        inline void setState(const I &State)
        {
            State_ = State;
        }
        inline const I& getState() const
        {
            return State_;
        }
        
        inline void setMin(const T &Min)
        {
            Min_ = Min;
        }
        inline const T& getMin() const
        {
            return Min_;
        }
        
        inline void setMax(const T &Max)
        {
            Max_ = Max;
        }
        inline const T& getMax() const
        {
            return Max_;
        }
        
    private:
        
        /* === Members === */
        
        T Min_, Max_;
        I State_;       
        I Speed_;
        
        bool Playing_;
        bool Finished_;
        
};

typedef FunctionalInterpolator<f32, f32, &Lerp> LinearInterpolator;
typedef FunctionalInterpolator<f32, f32, &LerpParabolic> ParabolicInterpolator;
typedef FunctionalInterpolator<f32, f32, &LerpSin> SinInterpolator;


} // /namespace math

} // /namespace sp


#endif



// ================================================================================