CWE-ou-minkata/Sources/Plasma/PubUtilLib/plInterp/hsTimedValue.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#ifndef hsTimedValue_inc
#define hsTimedValue_inc

#include "hsStream.h"

template <class T>
class hsTimedValue {
public:
    enum {
        kIdle           = 0x1,
        kInstant        = 0x2
    };
protected:
    UInt32                  fFlags;
    hsScalar                fDuration;
    hsScalar                fStartTime;

    T                       fValue;
    T                       fGoal;
    T                       fFrom;

public:
    hsTimedValue() : fFlags(kIdle|kInstant), fDuration(0) {}
    hsTimedValue(const T& v) : fFlags(kIdle|kInstant), fDuration(0) { SetValue(v); }

    UInt32 GetFlags() { return fFlags; }

    void SetDuration(hsScalar duration);
    hsScalar GetDuration() const { return fDuration; }

    hsBool32 operator==(const hsTimedValue<T>& v);
    hsTimedValue<T>& operator=(const T& v) { SetValue(v); return *this; }
    hsTimedValue<T>& operator+=(const T& v) { SetValue(v + fValue); return *this; }

    void SetTempValue(const T& v) { fValue = v; }
    void SetValue(const T& v) { fFrom = fGoal = fValue = v; fFlags |= kIdle; }
    const T& GetValue() const { return fValue; }

    void SetGoal(const T& g) { fGoal = g; }
    const T& GetGoal() const { return fGoal; }

    void Reset() { fFlags |= (kIdle | kInstant); }

    void StartClock(hsScalar s);
    hsScalar GetStartTime() const { return fStartTime; }

    const T& GetFrom() const { return fFrom; }

    void Update(hsScalar s);

    void WriteScalar(hsStream* s, hsScalar currSecs);
    void Write(hsStream* s, hsScalar currSecs);

    void ReadScalar(hsStream* s, hsScalar currSecs);
    void Read(hsStream* s, hsScalar currSecs);
};

template <class T>
void hsTimedValue<T>::WriteScalar(hsStream* s, hsScalar currSecs)
{
    s->WriteSwap32(fFlags);

    s->WriteSwapScalar(fValue);
    
    if( !(fFlags & kIdle) )
    {
        s->WriteSwapScalar(fDuration);
        s->WriteSwapScalar(currSecs - fStartTime);

        s->WriteSwapScalar(fGoal);
        s->WriteSwapScalar(fFrom);
    }
}

template <class T>
void hsTimedValue<T>::Write(hsStream* s, hsScalar currSecs)
{
    s->WriteSwap32(fFlags);

    fValue.Write(s);
    
    if( !(fFlags & kIdle) )
    {
        s->WriteSwapScalar(fDuration);
        s->WriteSwapScalar(currSecs - fStartTime);

        fGoal.Write(s);
        fFrom.Write(s);
    }
}

template <class T>
void hsTimedValue<T>::ReadScalar(hsStream* s, hsScalar currSecs)
{
    fFlags = s->ReadSwap32();

    fValue = s->ReadSwapScalar();

    if( !(fFlags & kIdle) )
    {
        fDuration = s->ReadSwapScalar();
        fStartTime = currSecs - s->ReadSwapScalar();

        fGoal = s->ReadSwapScalar();
        fFrom = s->ReadSwapScalar();
    }
}

template <class T>
void hsTimedValue<T>::Read(hsStream* s, hsScalar currSecs)
{
    fFlags = s->ReadSwap32();

    fValue.Read(s);

    if( !(fFlags & kIdle) )
    {
        fDuration = s->ReadSwapScalar();
        fStartTime = currSecs - s->ReadSwapScalar();

        fGoal.Read(s);
        fFrom.Read(s);
    }
}

template <class T>
void hsTimedValue<T>::SetDuration(hsScalar duration) 
{ 
    fDuration = duration; 
    if( fDuration > 0 )
        fFlags &= ~kInstant;
    else
        fFlags |= kInstant;
}

template <class T>
hsBool32 hsTimedValue<T>::operator==(const hsTimedValue<T>& v)
{
    if ((fFlags == v.fFlags) &&
        (fDuration == v.fDuration) &&
        (fStartTime == v.fStartTime) &&
        (fValue == v.fValue) &&
        (fGoal == v.fGoal) &&
        (fFrom == v.fFrom))
    {
        return true;
    }

    return false;
}

template <class T>
void hsTimedValue<T>::StartClock(hsScalar s)
{
    fStartTime = s;

    if( fFlags & kInstant )
    {
        fFlags |= kIdle;
        fValue = fGoal;
        return;
    }

    fFlags &= ~kIdle;

    if( fValue == fGoal )
        fFlags |= kIdle;

    fFrom = fValue;
}

template <class T>
void hsTimedValue<T>::Update(hsScalar s)
{
    if( fFlags & kIdle )
        return;

    hsAssert(fDuration > 0, "Instant should always be idle");

    hsScalar interp = (s - fStartTime) / fDuration;

    if( interp >= hsScalar1 )
    {
        fValue = fGoal;
        interp = hsScalar1;
        fFlags |= kIdle;
    }
    else
        fValue = fFrom + (fGoal - fFrom) * interp;
}



#endif // hsTimedValue_inc