3DKeyframe.h

Go to the documentation of this file.

//! @file 3DKeyframe.h
//! @brief The file contains different kind of keyframes definition
 
//////////////////////////////////////////////////////////////////////
 
#ifndef C3DKEYKEYFRAME_CLASS_H
#define C3DKEYKEYFRAME_CLASS_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "4x4Matrix.h"
#include "3DVector.h"
#include "CustomData.h"
#include "3DKeyCurve.h"
#include "RGBColor.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
class DLL_3DFUNCTION CTimeRange
{
public:
    typedef enum
    {
        MAX_TIME = INT_MAX,
    } SpecificTime;
 
    int start, end;
    
    CTimeRange();
    CTimeRange(int start, int end);
    
    BOOL IsInInterval(int time) const;
    unsigned int GetLength() const;
    int AdjustTime(int time) const;
    
    CTimeRange& operator|=(const CTimeRange& range);
    CTimeRange& operator&=(const CTimeRange& range);
};
 
class C3DKeyframable;
 
//! @class C3DKeyframe
//! @brief This is the base class for any keyframe that is part of C3DKeyframable class.
//! @details There is different kind of keyframe defined by KeyframeType.
//! C3DKeyframe::GetClassID can be used to cast a C3DKeyframe to the appropriate class.
class DLL_3DFUNCTION C3DKeyframe
{
protected:
    longuint classid; // The type of the keyframe and the content of the data
 
    CCustomData data;
    C3DKeyCurve *curve;
    C3DKeyframable* keyframes;
 
    C3DKeyframe& operator=(const C3DKeyframe& key) { MOOTOOLS_PRIVATE_ASSERT(0);  return *this; }; // Use CopyFrom
    void KeyFrameChanged(); // Called when the keyframe changed
 
public:
    //! @enum KeyframeType
    typedef enum KeyframeType
    {
        KEYFRAME_TYPE_NULLID = 0, //!< Keyframe not defined. Can be also used to retrieve any kind of keyframe
        KEYFRAME_TYPE_MATRIX = MAKE_CUSTOM_ID('M', 'A', 'T', 'R'), //!< C3DMatrixKey keyframe
        KEYFRAME_TYPE_TRANS = MAKE_CUSTOM_ID('T', 'R', 'A', 'N'), //!< C3DTranslateKey keyframe
        KEYFRAME_TYPE_SCALE = MAKE_CUSTOM_ID('S', 'C', 'A', 'L'), //!< C3DScaleKey keyframe
        KEYFRAME_TYPE_ROT = MAKE_CUSTOM_ID('R', 'O', 'T', 'A'), //!< C3DRotateKey keyframe
        KEYFRAME_TYPE_VECTOR = MAKE_CUSTOM_ID('V', 'E', 'C', 'T'), //!< C3DVectorKey keyframe
        KEYFRAME_TYPE_FLOAT = MAKE_CUSTOM_ID('F', 'L', 'O', 'A'), //!< C3DFloatKey keyframe
        KEYFRAME_TYPE_DOUBLE = MAKE_CUSTOM_ID('D', 'O', 'U', 'B'), //!< C3DDoubleKey keyframe
        KEYFRAME_TYPE_INT = MAKE_CUSTOM_ID(' ', 'I', 'N', 'T'), //!< C3DIntKey keyframe
        KEYFRAME_TYPE_UINT = MAKE_CUSTOM_ID('U', 'I', 'N', 'T'), //!< C3DUIntKey keyframe
        KEYFRAME_TYPE_COLOR = MAKE_CUSTOM_ID('C', 'O', 'L', 'O'), //!< C3DColorKey keyframe
    } KeyframeType;
 
    C3DKeyframe();
    virtual ~C3DKeyframe(void);
 
    void SetKeyframes(C3DKeyframable* keyframes);
    C3DKeyframable* GetKeyframes() const { return keyframes; }
 
    CCustomData& GetCustomData() { return data; }
 
    longuint GetClassID() const;
    unsigned int GetTypeID() const;
    unsigned int GetContentID() const;
 
    static C3DKeyframe *CreateKey(longuint classid, unsigned int curveClassid = C3DKeyCurve::KEYCURVE_NULLID);
    C3DKeyframe *Copy() const;
 
    void SetKeyCurve(C3DKeyCurve *curve);
    void SetKeyCurve(const C3DKeyCurve& curve);
    const C3DKeyCurve *GetKeyCurve() const;
    C3DKeyCurve *CreateCurve(unsigned int classid);
    
    virtual void Serialize(CXArchive& ar);
 
    virtual bool Evaluate(const C3DKeyframe& key1, const C3DKeyframe& key2, int time, const CTimeRange& range);
    virtual bool operator==(const C3DKeyframe& key) const;
    virtual C3DKeyframe& CopyFrom(const C3DKeyframe& key);
 
public:
#ifdef _DEBUG
    virtual bool Dump(int time, unsigned int flags) const;
#endif
};
 
#define KEYFRAMEID(classid, contentid) ((mootools::longuint)(((mootools::longuint)classid << 32) | (unsigned int)contentid))
#define KEYFRAMETYPE(classid) ((unsigned int)((mootools::longuint)classid >> 32))
#define KEYFRAMECONTENT(classid) ((unsigned int)(classid))
 
#define KEYFRAME_NULLID KEYFRAMEID(mootools::C3DKeyframe::KEYFRAME_TYPE_NULLID, mootools::C3DKeyframe::KEYFRAME_TYPE_NULLID)
#define KEYFRAME_MATRIX KEYFRAMEID(mootools::C3DKeyframe::KEYFRAME_TYPE_MATRIX, mootools::C3DKeyframe::KEYFRAME_TYPE_NULLID)
#define KEYFRAME_SCALE KEYFRAMEID(mootools::C3DKeyframe::KEYFRAME_TYPE_SCALE, mootools::C3DKeyframe::KEYFRAME_TYPE_NULLID)
#define KEYFRAME_ROT KEYFRAMEID(mootools::C3DKeyframe::KEYFRAME_TYPE_ROT, mootools::C3DKeyframe::KEYFRAME_TYPE_NULLID)
#define KEYFRAME_TRANS KEYFRAMEID(mootools::C3DKeyframe::KEYFRAME_TYPE_TRANS, MAKE_CUSTOM_ID('T', 'R', 'A', 'N'))
#define KEYFRAME_PIVOT KEYFRAMEID(mootools::C3DKeyframe::KEYFRAME_TYPE_VECTOR, MAKE_CUSTOM_ID('P', 'I', 'V', 'O'))
 
//! @class C3DMatrixKey
//! @brief This is the keyframe base class for transformation keyfrrame which allows to modify the node matrix transformation.
//! @details C3DTranslateKey, C3DScaleKey, C3DRotateKey... derived from C3DMatrixKey. Use C3DMatrixKey::ToMatrix() to get the corresponding transformation C4x4Matrix.
//!
class DLL_3DFUNCTION C3DMatrixKey : public C3DKeyframe
{
protected:
    C4x4Matrix matrix;
 
public:
    C3DMatrixKey(longuint classid);
    C3DMatrixKey(const C4x4Matrix& matrix);
 
    void SwapCoordinates(unsigned int swapMode, bool adjustMode);
 
    virtual const C4x4Matrix& ToMatrix() const;
    void SetMatrix(const C4x4Matrix& matrix);
 
    virtual void Serialize(CXArchive& ar);
 
    virtual bool Evaluate(const C3DKeyframe& key1, const C3DKeyframe& key2, int time, const CTimeRange& range);
    virtual bool operator==(const C3DKeyframe& key) const;
    virtual C3DKeyframe& CopyFrom(const C3DKeyframe& key);
 
#ifdef _DEBUG
    virtual bool Dump(int time, unsigned int flags) const;
#endif
};
 
//! @class C3DMatrixKey
//! @brief This class defines a rotation keyframe
class DLL_3DFUNCTION C3DRotateKey : public C3DMatrixKey
{
protected:
    double angle;
    C3DVector rotation;
 
public:
    C3DRotateKey(longuint classid);
    C3DRotateKey(real angle, const C3DVector& rotation);
 
    void SwapCoordinates(unsigned int swapMode);
 
    void SetRotation(double angle, const C3DVector& rotation);
    C3DVector GetRotation(double& angle) const;
    void SetQuaternion(const CQuaternion& quat);
    CQuaternion GetQuaternion() const;
 
    virtual void Serialize(CXArchive& ar);
 
    virtual bool Evaluate(const C3DKeyframe& key1, const C3DKeyframe& key2, int time, const CTimeRange& range);
    virtual C3DKeyframe& CopyFrom(const C3DKeyframe& key);
 
    using C3DMatrixKey::ToMatrix;
    using C3DMatrixKey::operator ==;
 
#ifdef _DEBUG
    bool Dump(int time, unsigned int flags) const;
#endif
};
 
//! @class C3DMatrixKey
//! @brief This class defines a translation keyframe
class DLL_3DFUNCTION C3DVectorKey : public C3DMatrixKey
{
protected:
    C3DVector vector;
 
public:
    C3DVectorKey(longuint classid);
 
    void SwapCoordinates(unsigned int swapMode);
 
    void SetVector(const C3DVector& vector);
    real *GetVectorPtr();
    C3DVector GetVector() const;
 
    virtual void Serialize(CXArchive& ar);
 
    virtual bool Evaluate(const C3DKeyframe& key1, const C3DKeyframe& key2, int time, const CTimeRange& range);
    virtual C3DKeyframe& CopyFrom(const C3DKeyframe& key);
    virtual void UpdateMatrix();
 
#ifdef _DEBUG
    bool Dump(int time, unsigned int flags) const;
#endif
};
 
//! @class C3DMatrixKey
//! @brief This class defines a scale keyframe
class DLL_3DFUNCTION C3DScaleKey : public C3DVectorKey
{
public:
    C3DScaleKey(longuint classid);
 
    void UpdateMatrix();
 
    using C3DVectorKey::operator ==; // Prevent C4263 & C4264 (unreal)
    using C3DVectorKey::operator =;
};
 
class DLL_3DFUNCTION C3DTranslateKey : public C3DVectorKey
{
public:
    C3DTranslateKey(longuint classid);
 
    void UpdateMatrix();
 
    using C3DVectorKey::operator ==; // Prevent C4263 & C4264 (unreal)
    using C3DVectorKey::operator =;
};
 
/////////////////////////////////////////
// Materials keys
 
//! @class C3DTypeKey
//! @brief This template class defines a keyframe of the specified TYPE
template<class TYPE> class C3DTypeKey : public C3DKeyframe
{
public:
    TYPE value;
 
public:
    C3DTypeKey(longuint classid);
    C3DTypeKey(unsigned int contentid, TYPE value);
 
    void SetValue(TYPE value);
    TYPE GetValue() const;
 
    unsigned int GetTypeID() const
    {
        XASSERT(0);
        return KEYFRAME_TYPE_NULLID;
    }
 
    virtual void Serialize(CXArchive& ar);
 
    virtual bool Evaluate(const C3DKeyframe& key1, const C3DKeyframe& key2, int time, const CTimeRange& range);
    virtual bool operator==(const C3DKeyframe& key) const;
    virtual C3DKeyframe& CopyFrom(const C3DKeyframe& key);
 
#ifdef _DEBUG
    virtual bool Dump(int time, unsigned int flags) const;
#endif
};
 
////////////////////////////////////////////////////////////
// C3DTypeKey
////////////////////////////////////////////////////////////
 
template <class TYPE> C3DTypeKey<TYPE>::C3DTypeKey(longuint classid)
{
    XASSERT(KEYFRAMETYPE(classid) == GetTypeID());
    this->classid = classid;
    value = 0;
}
 
template <class TYPE> C3DTypeKey<TYPE>::C3DTypeKey(unsigned int contentid, TYPE refvalue)
{
    classid =  KEYFRAMEID(GetTypeID(), contentid);
    this->value = refvalue;
}
 
template <class TYPE> void C3DTypeKey<TYPE>::SetValue(TYPE refvalue)
{
    this->value = refvalue;
}
 
template <class TYPE> TYPE C3DTypeKey<TYPE>::GetValue() const
{
    return value;
}
 
template <class TYPE> bool C3DTypeKey<TYPE>::operator==(const C3DKeyframe& key) const
{
    if (!C3DKeyframe::operator==(key))
        return false;
 
    return value == ((C3DTypeKey<TYPE>&)key).value;
}
 
template <class TYPE> void C3DTypeKey<TYPE>::Serialize(CXArchive& ar)
{
    C3DKeyframe::Serialize(ar);
 
    if (ar.IsStoring())
        ar << value;
    else
        ar >> value;
}
 
template <class TYPE> C3DKeyframe& C3DTypeKey<TYPE>::CopyFrom(const C3DKeyframe& key)
{
    C3DKeyframe::CopyFrom(key);
    if (classid != key.GetClassID())
        return (*this);
 
    this->value = ((C3DTypeKey<TYPE>&)key).value;
 
    return (*this);
}
 
template <class TYPE> bool C3DTypeKey<TYPE>::Evaluate(const C3DKeyframe& refkey1, const C3DKeyframe& refkey2, int time, const CTimeRange& range)
{
    const C3DTypeKey<TYPE>& key1 = (const C3DTypeKey<TYPE>&)refkey1;
    const C3DTypeKey<TYPE>& key2 = (const C3DTypeKey<TYPE>&)refkey2;
 
    double coef = (time-range.start)/(double)range.GetLength();
    value = (TYPE)(key1.value*(1.0-coef)+key2.value*coef);
 
    return true;
}
 
#ifdef _DEBUG
template <class TYPE> bool C3DTypeKey<TYPE>::Dump(int time, unsigned int flags) const
{
    if (!C3DKeyframe::Dump(time, flags))
        return false;
 
    CXTrace& trace = GetGlobalTrace();
    XTRACE(_T("Type Key %d %d:\n"), GetTypeID(), GetContentID());
    trace << value;
 
    return true;
}
#endif
 
//! @class C3DFloatKey
//! @extends C3DTypeKey
//! @brief This keyframe stores a float value information which can be get / set using SetValue() / GetValue() methods
//! @class C3DDoubleKey
//! @extends C3DTypeKey
//! @brief This keyframe stores a double value information which can be get / set using SetValue() / GetValue() methods
//! @class C3DIntKey
//! @extends C3DTypeKey
//! @brief This keyframe stores a int value information which can be get / set using SetValue() / GetValue() methods
//! @class C3DUIntKey
//! @extends C3DTypeKey
//! @brief This keyframe stores a unsigned int value information which can be get / set using SetValue() / GetValue() methods
//! @class C3DColorKey
//! @extends C3DTypeKey
//! @brief This keyframe stores a CRGBColor color information which can be get / set using SetValue() / GetValue() methods
typedef C3DTypeKey<float> C3DFloatKey;
typedef C3DTypeKey<double> C3DDoubleKey;
typedef C3DTypeKey<int> C3DIntKey;
typedef C3DTypeKey<unsigned int> C3DUIntKey;
typedef C3DTypeKey<CRGBColor> C3DColorKey;
 
/////////////////////////////////////////////////////////////////////
// Specialization
//////////////////////////////////////////////////////////////////////
 
#ifdef _DEBUG
template<> inline unsigned int C3DFloatKey::GetTypeID() const
{
    return KEYFRAME_TYPE_FLOAT;
}
 
template<> inline unsigned int C3DDoubleKey::GetTypeID() const
{
    return KEYFRAME_TYPE_DOUBLE;
}
 
template<> inline unsigned int C3DIntKey::GetTypeID() const
{
    return KEYFRAME_TYPE_INT;
}
 
template<> inline unsigned int C3DUIntKey::GetTypeID() const
{
    return KEYFRAME_TYPE_UINT;
}
 
template<> inline unsigned int C3DColorKey::GetTypeID() const
{
    return KEYFRAME_TYPE_COLOR;
}
 
//template unsigned int C3DFloatKey::GetTypeID() const;
//template unsigned int C3DDoubleKey::GetTypeID() const;
//template unsigned int C3DIntKey::GetTypeID() const;
//template unsigned int C3DUIntKey::GetTypeID() const;
//template unsigned int C3DColorKey::GetTypeID() const;
#endif
 
END_MOOTOOLS_NAMESPACE
 
#endif // C3DKEYKEYFRAME_CLASS_H