cValueLerp.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cValueLerp_H
#define _INC_cValueLerp_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "Calc.h"
#include "GrayCore/include/cTimeSys.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cValueLerp);
 
        template <typename TYPE>
        class cValueLerp
        {
        private:
                TYPE m_nValCur;         
                TIMESYS_t m_TimeLast;   
        public:
                cValueLerp(TYPE nValCur = 0) noexcept
                        : m_nValCur(nValCur)
                        , m_TimeLast(cTimeSys::k_CLEAR)
                {
                }
                TYPE get_Val() const noexcept
                {
                        return m_nValCur;
                }
                void put_Val(TYPE nValCur) noexcept
                {
                        m_nValCur = nValCur;
                        m_TimeLast = cTimeSys::k_CLEAR;
                }
 
                static bool TickX(TYPE& nValCur, TYPE nValEnd, TIMESECF_t fTimePassed, float fValPerSec)
                {
 
                        ASSERT(fValPerSec > 0); // allowed change rate per sec.
                        ASSERT(fTimePassed >= 0);
 
                        TYPE nDiff = nValEnd - nValCur; // How far left to go ?
                        if (nDiff == 0)
                        {
                                return false;   // done
                        }
                        float fChange = fValPerSec * fTimePassed;
                        TYPE nDiffA = Calc::Abs(nDiff); // How far left to go ABS ?
                        if (fChange >= nDiffA)
                        {
                                nValCur = nValEnd;      // reached my goal. Stop.
                                return true;
                        }
 
                        // always do the compare as a float to watch for overflow!
                        TYPE nValNext;
                        if (nDiff > 0)
                        {
                                nValNext = (TYPE)(nValCur + fChange);
                        }
                        else
                        {
                                nValNext = (TYPE)(nValCur - fChange);
                        }
                        if (nValCur == nValNext)
                                return false;   // no change with this amount of time. (mostly for integer types)
                        nValCur = nValNext;
                        return true;    // there is a value change. for integer types.
                }
 
                bool TickCap(float fValPerSec, TYPE nValEnd, TIMESYS_t TimeNow = cTimeSys::k_CLEAR)
                {
 
                        ASSERT(fValPerSec > 0); // allowed change rate per second.
                        if (m_nValCur == nValEnd)
                        {
                                m_TimeLast = cTimeSys::k_CLEAR; // finished.
                                return false;
                        }
 
                        if (TimeNow == cTimeSys::k_CLEAR)
                        {
                                TimeNow = cTimeSys::GetTimeNow();
                        }
                        if (m_TimeLast != cTimeSys::k_CLEAR)    // starting motion.
                        {
                                TIMESYSD_t nTimeDiff = TimeNow - m_TimeLast;
                                if (nTimeDiff > 0)      // SKIP time wrap!!
                                {
                                        if (!TickX(m_nValCur, nValEnd, ((float)nTimeDiff) / cTimeSys::k_FREQ, fValPerSec))
                                        {
                                                return false;   // not enough time to make a whole digit change (integer). dont advace time.
                                        }
                                        // Should we adjust TimeNow to undo partial (non integer) values ? 
                                }
                        }
                        m_TimeLast = TimeNow;   
                        return true;
                }
 
                UNITTEST_FRIEND(cValueLerp);
        };
}
#endif