CWE-ou-minkata/Sources/Plasma/PubUtilLib/plInterp/plAnimTimeConvert.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 plAnimTimeConvert_inc
#define plAnimTimeConvert_inc

#include "pnFactory/plCreatable.h"
#include "hsTemplates.h"
#include "pnNetCommon/plSynchedValue.h"

#pragma warning (disable: 4284) 

class plSynchedObject;
class plAnimCmdMsg;
class plEventCallbackMsg;
class plATCEaseCurve;
class plATCState;
class plATCAnim;
class plAGMasterMod;
class plAGAnimInstance;

class plAnimTimeConvert : public plCreatable
{
    friend class plAnimTimeConvertSDLModifier;
    friend class plAGAnimInstance;

protected:
    UInt16                  fFlags;
    hsScalar                fBegin;
    hsScalar                fEnd;
    hsScalar                fLoopEnd;
    hsScalar                fLoopBegin;
    hsScalar                fSpeed;
    hsScalar                fCurrentAnimTime;
    hsScalar                fWrapTime;
    double                  fLastEvalWorldTime;
    // Do not change fLastEvalWorldTime anywhere except WorldToAnimTime()

    plSynchedObject*                            fOwner;
    double                                      fLastStateChange;

    typedef std::list<plATCState *> plATCStateList;
    plATCStateList fStates;
    
    hsTArray<hsScalar>              fStopPoints;
    hsTArray<plEventCallbackMsg*>   fCallbackMsgs;

    /////////////////////////
    // Ease In/Out stuff

    plATCEaseCurve *fEaseInCurve;
    plATCEaseCurve *fEaseOutCurve;
    plATCEaseCurve *fSpeedEaseCurve;
    plATCEaseCurve *fCurrentEaseCurve; // One of the above, or nil

    //
    /////////////////////////

    hsScalar fInitialBegin;
    hsScalar fInitialEnd;

    static hsScalar ICalcEaseTime(const plATCEaseCurve *curve, double start, double end);
    void            IClearSpeedEase();

    void        ICheckTimeCallbacks(hsScalar frameStart, hsScalar frameStop);
    hsBool      ITimeInFrame(hsScalar secs, hsScalar start, hsScalar stop);
    void        ISendCallback(int i);

    plAnimTimeConvert& IStop(double time, hsScalar animTime);
    hsBool IIsStoppedAt(const double &wSecs, const UInt32 &flags, const plATCEaseCurve *curve) const;
    plAnimTimeConvert& IProcessStateChange(double worldTime, hsScalar animTime = -1);
    void IFlushOldStates();
    void IClearAllStates();
    plATCState *IGetState(double wSecs) const;
    plATCState *IGetLatestState() const;
    
    plAnimTimeConvert& SetFlag(UInt8 f, hsBool on) { if(on)fFlags |= f; else fFlags &= ~f; return *this; }

public:
    plAnimTimeConvert();
    virtual ~plAnimTimeConvert();

    void Init(plATCAnim *anim, plAGAnimInstance *instance, plAGMasterMod *master);

    CLASSNAME_REGISTER( plAnimTimeConvert );
    GETINTERFACE_ANY( plAnimTimeConvert, plCreatable );

    void SetOwner(plSynchedObject* o);
    const plSynchedObject* GetOwner() const { return fOwner; }

    // ALL WorldToAnimTime functions are only valid if called with a time >= fLastEvalWorldTime.
    hsBool      IsStoppedAt(double wSecs) const;
    hsScalar    WorldToAnimTime(double wSecs);
    hsScalar    WorldToAnimTimeNoUpdate(double wSecs) const; // convert time but don't fire triggers or set state
    
protected:
    static hsScalar IWorldToAnimTimeNoUpdate(double wSecs, plATCState *state);
    hsScalar IWorldToAnimTimeBeforeState(double wSecs) const;

public:
    void SetBegin(hsScalar s) { fBegin = s; }
    void SetEnd(hsScalar s) { fEnd = s; }
    void SetSpeed(hsScalar goal, hsScalar rate = 0);
    void SetLoopPoints(hsScalar begin, hsScalar end) { SetLoopBegin(begin); SetLoopEnd(end); }
    void SetLoopBegin(hsScalar s) { fLoopBegin = s; }
    void SetLoopEnd(hsScalar s) { fLoopEnd = s; }
    void SetEase(hsBool easeIn, UInt8 inType, hsScalar minLength, hsScalar maxLength, hsScalar inLength);
    void SetCurrentEaseCurve(int x);    // 0=nil, 1=easeIn, 2=easeOut, 3=speed

    hsScalar GetBegin() const { return fBegin; }
    hsScalar GetEnd() const { return fEnd; }
    hsScalar GetLoopBegin() const { return fLoopBegin; }
    hsScalar GetLoopEnd() const { return fLoopEnd; }
    hsScalar GetSpeed() const { return fSpeed; }
    hsTArray<hsScalar> &GetStopPoints() { return fStopPoints; }
    hsScalar GetBestStopDist(hsScalar min, hsScalar max, hsScalar norm, hsScalar time) const;
    int GetCurrentEaseCurve() const;    // returns  0=nil, 1=easeIn, 2=easeOut, 3=speed

    void ResizeStates(int cnt);
    void ResetWrap();

    plAnimTimeConvert& ClearFlags() { fFlags = kNone; return *this; }
    hsBool GetFlag(UInt8 f) const { return (fFlags & f) ? true : false; }

    plAnimTimeConvert& InitStop(); // Called when initializing an anim that doesn't autostart
    plAnimTimeConvert& Stop(hsBool on);
    plAnimTimeConvert& Stop(double s = -1.0);
    plAnimTimeConvert& Start(double s = -1.0);
    plAnimTimeConvert& PlayToTime(hsScalar time);
    plAnimTimeConvert& PlayToPercentage(hsScalar percent); // zero to one.
        
    plAnimTimeConvert& Loop(hsBool on);
    plAnimTimeConvert& Loop() { return Loop(true); }
    plAnimTimeConvert& NoLoop() { return Loop(false); }

    plAnimTimeConvert& Backwards(hsBool on);
    plAnimTimeConvert& Backwards();
    plAnimTimeConvert& Forewards();

    hsBool IsStopped() const { return 0 != (fFlags & kStopped); }
    hsBool IsLooped() const { return 0 != (fFlags & kLoop); }
    hsBool IsBackwards() const { return 0 != (fFlags & kBackwards); }
    hsBool IsForewards() const { return !(fFlags & kBackwards); }

    double LastEvalWorldTime() const { return fLastEvalWorldTime; }
    hsScalar CurrentAnimTime() const { return fCurrentAnimTime; }
    void SetCurrentAnimTime(hsScalar s, hsBool jump = false);

    virtual void Read(hsStream* s, hsResMgr* mgr);
    virtual void Write(hsStream* s, hsResMgr* mgr);

    hsBool HandleCmd(plAnimCmdMsg* msg);
    void AddCallback(plEventCallbackMsg* pMsg);
    void RemoveCallback(plEventCallbackMsg* pMsg);
    void ClearCallbacks();
    void EnableCallbacks(hsBool val);
    
    enum plAnimTimeFlags {
        kNone           = 0x0,
        kStopped        = 0x1,
        kLoop           = 0x2,
        kBackwards      = 0x4,
        kWrap           = 0x8,
        kNeedsReset     = 0x10,
        kEasingIn       = 0x20,
        kForcedMove     = 0x40,
        kNoCallbacks    = 0x80,

        kFlagsMask      = 0xff
    };
    
    enum plEaseCurveType {
        kEaseNone,
        kEaseIn,
        kEaseOut,
        kEaseSpeed,
    };

};

// Rules for happy ease curves:
//      1. Any time value between 0 and fLength is kosher.
//      2. Velocity values accepted/returned are in the range [fStartSpeed, fSpeed]
//          (some tolerance for values REALLY close to the limit, to account for floating-point inaccuracy)

class plATCEaseCurve : public plCreatable
{
protected:
    hsScalar fStartSpeed;
    hsScalar fMinLength;
    hsScalar fMaxLength;
    hsScalar fNormLength;

public:
    CLASSNAME_REGISTER( plATCEaseCurve );
    GETINTERFACE_ANY( plATCEaseCurve, plCreatable );

    double fBeginWorldTime;
    hsScalar fLength;
    hsScalar fSpeed; // The anim's target ("full") speed.

    static plATCEaseCurve *CreateEaseCurve(UInt8 type, hsScalar minLength, hsScalar maxLength, hsScalar normLength, 
                                           hsScalar startSpeed, hsScalar goalSpeed);

    double GetEndWorldTime() const { return fBeginWorldTime + fLength; } 

    virtual plATCEaseCurve *Clone() const = 0;
    virtual void Read(hsStream *s, hsResMgr *mgr);
    virtual void Write(hsStream *s, hsResMgr *mgr);
    
    virtual void RecalcToSpeed(hsScalar startSpeed, hsScalar goalSpeed, hsBool preserveRate = false);
    virtual void SetLengthOnRate(hsScalar rate);
    virtual void SetLengthOnDistance(hsScalar dist) = 0;
    virtual hsScalar PositionGivenTime(hsScalar time) const = 0;
    virtual hsScalar VelocityGivenTime(hsScalar time) const = 0;
    virtual hsScalar TimeGivenVelocity(hsScalar velocity) const = 0;
    virtual hsScalar GetMinDistance();
    virtual hsScalar GetMaxDistance();
    virtual hsScalar GetNormDistance();
};

class plConstAccelEaseCurve : public plATCEaseCurve
{
public:
    plConstAccelEaseCurve();
    plConstAccelEaseCurve(hsScalar minLength, hsScalar maxLength, hsScalar length, 
                          hsScalar startSpeed, hsScalar goalSpeed);

    CLASSNAME_REGISTER( plConstAccelEaseCurve );
    GETINTERFACE_ANY( plConstAccelEaseCurve, plATCEaseCurve );

    virtual plATCEaseCurve *Clone() const;
    virtual void SetLengthOnDistance(hsScalar dist);
    virtual hsScalar PositionGivenTime(hsScalar time) const;
    virtual hsScalar VelocityGivenTime(hsScalar time) const;
    virtual hsScalar TimeGivenVelocity(hsScalar velocity) const;
};

class plSplineEaseCurve : public plATCEaseCurve
{
public:
    plSplineEaseCurve();
    plSplineEaseCurve(hsScalar minLength, hsScalar maxLength, hsScalar length, 
                      hsScalar startSpeed, hsScalar goalSpeed);

    CLASSNAME_REGISTER( plSplineEaseCurve );
    GETINTERFACE_ANY( plSplineEaseCurve, plATCEaseCurve );

    virtual void Read(hsStream *s, hsResMgr *mgr);
    virtual void Write(hsStream *s, hsResMgr *mgr);

    virtual plATCEaseCurve *Clone() const;
    virtual void RecalcToSpeed(hsScalar startSpeed, hsScalar goalSpeed, hsBool preserveRate = false); 
    virtual void SetLengthOnDistance(hsScalar dist);
    virtual hsScalar PositionGivenTime(hsScalar time) const;
    virtual hsScalar VelocityGivenTime(hsScalar time) const;
    virtual hsScalar TimeGivenVelocity(hsScalar velocity) const;

    hsScalar fCoef[4];
};

class plATCState
{
public:
    plATCState() : fEaseCurve(nil) {}
    ~plATCState() { delete fEaseCurve; }

    void Read(hsStream *s, hsResMgr *mgr);
    void Write(hsStream *s, hsResMgr *mgr);

    double fStartWorldTime;
    hsScalar fStartAnimTime;

    UInt8 fFlags;
    hsScalar fBegin;
    hsScalar fEnd;
    hsScalar fLoopBegin;
    hsScalar fLoopEnd;
    hsScalar fSpeed;
    hsScalar fWrapTime;
    plATCEaseCurve *fEaseCurve;
};


#endif // plAnimTimeConvert_inc