3DAnimatable.h

Go to the documentation of this file.

//! @file 3DAnimatable.h
//! @brief C3DKeyframable class for handling keyframes
//!
//////////////////////////////////////////////////////////////////////
 
#ifndef C3DANIMATABLE_H
#define C3DANIMATABLE_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "CustomData.h"
#include "3DKeyframe.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
class C3DKeyframe;
class CTimeRange;
 
//! @class C3DAnimatable
//! @brief C3DAnimatable is the base class for any object which inherits an animation.
//! @details A C3DScene is not directly animatable but inherits animation as it contains C3DSceneNode which are animated. Any classe which derive from C3DKeyframable are animatable.
class DLL_3DFUNCTION C3DAnimatable
{
public:
    //! @enum FindKey
    //! 
    enum FindKey
    {
        KEYFRAME_PREV = 0x01, //!< Retrieves closest keyframe after the given time
        KEYFRAME_NEXT = 0x02, //!< Retrieves closest keyframe before the given time 
        KEYFRAME_SAME = 0x04 //!<  Retrieves keyframe at the given time 
    };
 
    C3DAnimatable();
    virtual ~C3DAnimatable();
 
    int GetKeyTime(int time, unsigned int pos, longuint classid = KEYFRAME_NULLID);
 
    virtual CTimeRange GetTimeRange(longuint classid = KEYFRAME_NULLID) const = 0;
    virtual const C3DKeyframe *GetConstKey(int time, unsigned int pos, longuint classid = KEYFRAME_NULLID, int *findKeyTime = NULL) const = 0;
};
 
//! @class C3DKeyframable
//! @brief This is the base class for any object that can be animated using C3DKeyframe.
//! @details The C3DSceneNode derived from this class and handles KEYFRAME_MATRIX, KEYFRAME_SCALE, KEYFRAME_ROT, KEYFRAME_TRANS keyframes.
//! It is possible to add / remove keyframe of any kind and to evaluate the interpolation of 2 keyframes
class C3DKeyframe;
class DLL_3DFUNCTION C3DKeyframable : public C3DAnimatable
{
    friend C3DKeyframe;
 
public:
    typedef enum TimeStamp
    {
        INVALID_TIME = -1,
    } TimeStamp;
 
private:
    typedef struct _KeyframeInfo
    {
        int time;
        C3DKeyframe *key;
 
        _KeyframeInfo()
        {
            time = 0;
            key = NULL;
        };
 
        _KeyframeInfo(int reftime, C3DKeyframe *refkey)
        {
            this->time = reftime;
            this->key = refkey;
        };
    } KeyframeInfo;
 
    typedef struct _KeyCache
    {
        int time;
        C3DKeyframe *key; // key at given time
 
        _KeyCache()
        {
            time = INVALID_TIME;
            key = NULL;
        }
    } KeyCache;
 
    CXArray<KeyframeInfo> keys;
    mutable CXArray<KeyCache> cache;
 
    void InitCache();
    void InvalidateCache(longuint classID = KEYFRAME_NULLID) const;
    C3DKeyframe * CreateCacheKey(int time, longuint classID, const C3DKeyframe *fromKey) const;
    bool FindCache(int time, longuint classID, C3DKeyframe *& key) const;
 
    void KeyframesChanged(longuint classid = KEYFRAME_NULLID) const;
    const C3DKeyframe *GetKey(int time, unsigned int findKeyFlag, longuint classid = KEYFRAME_NULLID, int *findKeyTime = NULL) const;
 
public:
    enum KeyframeFlags
    {
        KEYFRAME_NONE = 0x00,
        KEYFRAME_REPLACE_KEY = 0x01, //!< The created keyframe replaces the previous one
        KEYFRAME_DONT_EVALUATE = 0x02, //!< The created is not evaluate during creation. If not specified, the created keyframe is the interpolation of the adjacent keyframes
    };
 
    C3DKeyframable(void);
    virtual ~C3DKeyframable(void);
 
    int AddKey(int time, C3DKeyframe *newkey); //!< Return -1 if fails or keyframe number
    int AddKey(int time, const C3DKeyframe& newkey);  //!< Return keyframe number
    int DeleteKey(int time, longuint classid = KEYFRAME_NULLID); //!< If time = INVALID_TIME, then all key of classid are deleted or all keys are deleted if classid = KEYFRAME_NULLID
    void DeleteAllKeys();
    
    C3DKeyframe *CreateKey(int time, longuint classid, unsigned int flags = KEYFRAME_NONE); //!< Create key of the given classid. flags is one or more #KeyframeFlags
    C3DKeyframe *GetKeyByIndex(unsigned int index, int *time = NULL, longuint classid = KEYFRAME_NULLID); //!< This invalidate the cache, and can lead to slower computation
    const C3DKeyframe *GetConstKeyByIndex(unsigned int index, int *time = NULL, longuint classid = KEYFRAME_NULLID) const;
 
    int GetKeyNbr(longuint classid = KEYFRAME_NULLID) const;
    bool Evaluate(int time, C3DKeyframe& findkey) const; //!< This method evaluate the key at the given time. Same but slower that the following method that return a pointer
    const C3DKeyframe *Evaluate(int time, longuint classid) const; //!< This method evaluate the key at the given time. This is the fastest method. The key content cannot be changed
    int CopyKeys(const C3DKeyframable *srckeys, longuint classid = KEYFRAME_NULLID, CTimeRange range = CTimeRange(0, CTimeRange::MAX_TIME)); //!< Copy key of the given classid in the given time range
 
    bool operator==(const C3DKeyframable& refkeys) const;
    bool operator=(const C3DKeyframable& key);
    
    virtual void Serialize(CXArchive& ar);
 
    // Animatable overiden
    virtual void OnKeyframesChanged(longuint classID) const; // Notify that something changed in the keyframes. classID == KEYFRAME_NULLID, if all kind of keyframe changed
    virtual CTimeRange GetTimeRange(longuint classid = KEYFRAME_NULLID) const;
    virtual const C3DKeyframe *GetConstKey(int time, unsigned int findKeyFlag, longuint classid = KEYFRAME_NULLID, int *findKeyTime = NULL) const; //!< Retrieve a keyframe at / before or after the specified time depending on findKeyFlag
 
#ifdef _DEBUG
    virtual bool Dump(unsigned int flags) const;
    virtual bool DumpKeyList(unsigned int flags) const;
#endif
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // C3DANIMATABLE_H