AnimPath.h

//
// AnimPath.h
//
// Implementation animation path capabilities.
//
// Copyright (c) 2004-2011 Virtual Terrain Project
// Free for all uses, see license.txt for details.
//

#ifndef ANIMPATHH
#define ANIMPATHH

#include "Engine.h"
#include "vtdata/CubicSpline.h"
#include "vtdata/Features.h"


struct ControlPoint
{
    ControlPoint() {}

    ControlPoint(const FPoint3 &position):
        m_Position(position),
        m_Rotation() {}

    ControlPoint(const FPoint3 &position, const FQuat &rotation):
        m_Position(position),
        m_Rotation(rotation) {}

    void Interpolate(double ratio,const ControlPoint &first, const ControlPoint &second);
    void GetMatrix(FMatrix4 &matrix, bool bPosOnly = false) const;

    FPoint3 m_Position;
    FQuat m_Rotation;
    int m_iIndex;
};

class vtAnimPath : public osg::Referenced
{
public:
    vtAnimPath();
    vtAnimPath(const vtAnimPath &ap);
    virtual ~vtAnimPath();

    bool SetProjection(const vtProjection &proj);

    bool GetMatrix(double time, FMatrix4 &matrix, bool bPosOnly) const
    {
        ControlPoint cp;
        if (!GetInterpolatedControlPoint(time,cp))
            return false;
        cp.GetMatrix(matrix, bPosOnly);
        return true;
    }

    virtual bool GetInterpolatedControlPoint(double time, ControlPoint &controlPoint) const;

    void Insert(double time, const ControlPoint &controlPoint);
    void RemovePoint(int index);
    uint GetNumPoints() { return m_TimeControlPointMap.size(); }

    void SetTimeFromLinearDistance();
    void ProcessPoints();

    double GetFirstTime() const;
    double GetLastTime() const;
    double GetPeriod() const { return GetLastTime()-GetFirstTime();}
    float GetTotalTime();

    enum InterpMode
    {
        LINEAR,
        CUBIC_SPLINE
    };
    void SetInterpMode(InterpMode mode) { m_InterpMode = mode; }
    InterpMode GetInterpMode() const { return m_InterpMode; }

    typedef std::map<double,ControlPoint> TimeControlPointMap;

    TimeControlPointMap &GetTimeControlPointMap() { return m_TimeControlPointMap; }
    const TimeControlPointMap &GetTimeControlPointMap() const { return m_TimeControlPointMap; }

    void Empty() { m_TimeControlPointMap.clear(); }
    bool IsEmpty() const { return m_TimeControlPointMap.empty(); }

    void SetLoop(bool bFlag);
    bool GetLoop() const { return m_bLoop; }

    bool Write(const char *fname);
    bool Read(const char *fname);

    bool CreateFromLineString(const vtProjection &proj, vtFeatureSet *pSet);

protected:
    void InterpolateControlPoints(TimeControlPointMap::const_iterator &a,
                                  TimeControlPointMap::const_iterator &b,
                                  double time,
                                  ControlPoint &c) const;
    TimeControlPointMap m_TimeControlPointMap;

    InterpMode      m_InterpMode;
    CubicSpline     m_Spline;
    bool            m_bLoop;
    double          m_fLoopSegmentTime;
    ControlPoint    m_LoopControlPoint;

    // For dealing with global projection
    vtProjection    m_proj;
    OCT         *m_pConvertToWGS;
    OCT         *m_pConvertFromWGS;
    friend class AnimPathVisitor;
};
typedef osg::ref_ptr<vtAnimPath> vtAnimPathPtr;

class vtAnimPathEngine : public vtEngine
{
public:
    vtAnimPathEngine():
        m_pAnimationPath(NULL),
        m_bContinuous(false),
        m_fLastTime(FLT_MAX),
        m_fTime(0.0f),
        m_bPosOnly(false),
        m_fSpeed(1.0f) {}

    vtAnimPathEngine(vtAnimPath *ap):
        m_pAnimationPath(ap),
        m_bContinuous(false),
        m_fLastTime(FLT_MAX),
        m_fTime(0.0f),
        m_bPosOnly(false),
        m_fSpeed(1.0f) {}

    void SetAnimationPath(vtAnimPath* path) { m_pAnimationPath = path; }
    vtAnimPath* GetAnimationPath() { return m_pAnimationPath; }
    const vtAnimPath* GetAnimationPath() const { return m_pAnimationPath; }

    void UpdateTargets();
    void Reset();

    void SetSpeed(float fSpeed) { m_fSpeed = fSpeed; }
    float GetSpeed() const { return m_fSpeed; }

    void SetContinuous(bool bFlag) { m_bContinuous = bFlag; }
    bool GetContinuous() const { return m_bContinuous; }

    void SetPosOnly(bool bFlag) { m_bPosOnly = bFlag; }
    bool GetPosOnly() const { return m_bPosOnly; }

    virtual void Eval();
    virtual void SetEnabled(bool bOn);

    void SetTime(float fTime) { m_fTime = fTime; }
    float GetTime() { return m_fTime; }

public:
    vtAnimPathPtr m_pAnimationPath;     // the engine owns the animpath
    bool    m_bContinuous;
    float   m_fLastTime;
    float   m_fTime;
    bool    m_bPosOnly;
    float   m_fSpeed;
};

/* Convenience classes for organizing a set of animation paths with their engines. */
struct vtAnimEntry
{
    vtAnimPath *m_pAnim;
    vtAnimPathEngine *m_pEngine;
    vtString m_Name;
};

class vtAnimContainer : public std::vector<vtAnimEntry>
{
public:
    void SetEngineContainer(vtEngine *pContainer)
    {
        m_pParentEngine = pContainer;
    }
    void AppendEntry(const vtAnimEntry &pEntry);

protected:
    vtEnginePtr m_pParentEngine;
};
  // nav

#endif // ANIMPATHH