D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/SceneGraph/Animation/spKeyframeSequence.hpp

Go to the documentation of this file.

/*
 * Keyframe sequence header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_KEYFRAME_SEQUENCE_H__
#define __SP_KEYFRAME_SEQUENCE_H__


#include "Base/spStandard.hpp"
#include "Base/spTransformation3D.hpp"

#include <vector>


namespace sp
{
namespace scene
{


enum EKeyframeFlags
{
    KEYFRAME_POSITION   = 0x01,
    KEYFRAME_ROTATION   = 0x02,
    KEYFRAME_SCALE      = 0x04,
    KEYFRAME_ALL        = KEYFRAME_POSITION | KEYFRAME_ROTATION | KEYFRAME_SCALE,
};


class SP_EXPORT KeyframeSequence
{
    
    public:
        
        KeyframeSequence();
        ~KeyframeSequence();
        
        /* === Functions === */
        
        #if 1 //!!!
        
        void addKeyPosition(u32 Frame, const dim::vector3df &Position);
        void addKeyRotation(u32 Frame, const dim::quaternion &Rotation);
        void addKeyScale(u32 Frame, const dim::vector3df &Scale);
        
        void addKeyframe(u32 Frame, s32 _deb_ToBeremoved_, const Transformation &Transform, s32 Flags = KEYFRAME_ALL);
        
        bool removeKeyframe(u32 Frame, s32 _deb_ToBeremoved_, s32 Flags = KEYFRAME_ALL);
        
        bool updateSequence();
        
        void setUpdateImmediate(bool Enable);
        
        #endif
        
        void addKeyframe(u32 Frame, const Transformation &Transform);
        
        void removeKeyframe(u32 Frame);
        
        /* === Inline functions === */
        
        inline const Transformation& getKeyframe(u32 Frame) const
        {
            return Keyframes_[Frame];
        }
        inline Transformation& getKeyframe(u32 Frame)
        {
            return Keyframes_[Frame];
        }
        
        inline void interpolate(Transformation &Result, u32 From, u32 To, f32 Interpolation)
        {
            const u32 FrameCount = Keyframes_.size();
            if (From < FrameCount && To < FrameCount)
                Result.interpolate(Keyframes_[From], Keyframes_[To], Interpolation);
        }
        
        inline u32 getKeyframeCount() const
        {
            return Keyframes_.size();
        }
        
        inline u32 getMinKeyframe() const
        {
            return MinFrame_;
        }
        inline u32 getMaxKeyframe() const
        {
            return MaxFrame_;
        }
        
        inline bool getUpdateImmediate() const
        {
            return UpdateImmediate_;
        }
        
        inline bool modified() const
        {
            return Modified_;
        }
        
    private:
        
        /* === Structures === */
        
        #if 1 //!!!
        
        template <class VecT> struct SKey
        {
            SKey() :
                Frame(0)
            {
            }
            SKey(u32 FrameIndex, const VecT &KeyVec) :
                Frame   (FrameIndex ),
                Vec     (KeyVec     )
            {
            }
            ~SKey()
            {
            }
            
            /* Members */
            u32 Frame;
            VecT Vec;
        };
        
        typedef SKey<dim::vector3df> SKeyPos;
        typedef SKey<dim::quaternion> SKeyRot;
        typedef SKey<dim::vector3df> SKeyScl;
        
        #endif
        
        /* === Functions === */
        
        void findRootFrameRange(u32 Frame, u32* LeftFrame, u32* RightFrame);
        
        void pushBackKeyframe(const Transformation &Transform, u32 Frame);
        void insertKeyframe(const Transformation &Transform, u32 Frame);
        
        void popBackKeyframe(u32 Frame);
        void extractKeyframe(u32 Frame);
        
        #if 1 //!!!
        
        void updateFrameRangeComplete();
        void markAsModified();
        
        #endif
        
        /* === Templates === */
        
        template <typename T> void insertKey(std::vector<T> &Keyframes, const T &Key)
        {
            /* Presuem that new keyframes will be added from left to right (smaller frame indices up to higher ones).
               So insert the new key before the first existing key whose frame is smaller that the new one's.
               By iterating from front to back in the list. */
            typename std::vector<T>::reverse_iterator it = Keyframes.rbegin();
            
            while (it != Keyframes.rend() && it->Frame > Key.Frame)
                ++it;
            
            if (it != Keyframes.rend() && it->Frame == Key.Frame)
                it->Vec = Key.Vec;
            else
            {
                /* Insert new keyframe */
                Keyframes.insert(it.base(), Key);
                
                /* Update minimal- and maximal frame indices */
                math::Decrease(MinFrame_, Key.Frame);
                math::Increase(MaxFrame_, Key.Frame);
            }
        }
        
        template <typename T> bool removeKey(std::vector<T> &Keyframes, u32 Frame)
        {
            for (typename std::vector<T>::iterator it = Keyframes.begin(); it != Keyframes.end(); ++it)
            {
                if (it->Frame == Frame)
                {
                    Keyframes.erase(it);
                    return true;
                }
            }
            return false;
        }
        
        template <typename T> void updateFrameRange(std::vector<T> &Keyframes)
        {
            for (typename std::vector<T>::iterator it = Keyframes.begin(); it != Keyframes.end(); ++it)
            {
                math::Decrease(MinFrame_, it->Frame);
                math::Increase(MaxFrame_, it->Frame);
            }
        }
        
        template <typename T> void filterMinFrame(std::vector<T> &Keyframes)
        {
            if (!Keyframes.empty())
            {
                const u32 Frame = Keyframes.back().Frame;
                if (MinFrame_ > Frame)
                    MinFrame_ = Frame;
            }
        }
        
        template <typename T> void filterMaxFrame(std::vector<T> &Keyframes)
        {
            if (!Keyframes.empty())
            {
                const u32 Frame = Keyframes.front().Frame;
                if (MaxFrame_ < Frame)
                    MaxFrame_ = Frame;
            }
        }
        
        template <typename T, class VecT> typename std::vector<T>::iterator getFirstInterpVectors(
            std::vector<T> &Keyframes, VecT &FromVec, VecT &ToVec, u32 &FromIndex, u32 &ToIndex)
        {
            typename std::vector<T>::iterator it = Keyframes.begin();
            
            if (it != Keyframes.end())
            {
                FromVec     = it->Vec;
                FromIndex   = it->Frame;
                
                ++it;
                if (it != Keyframes.end())
                {
                    ToVec   = it->Vec;
                    ToIndex = it->Frame;
                }
                else
                {
                    ToVec   = FromVec;
                    ToIndex = FromIndex;
                }
            }
            
            ++ToIndex;
            
            return it;
        }
        
        template <typename T, class VecT> void getNextInterpIterator(
            std::vector<T> &Keyframes, typename std::vector<T>::iterator &it, u32 Frame,
            VecT &FromVec, VecT &ToVec, u32 &FromIndex, u32 &ToIndex)
        {
            if (it != Keyframes.end() && Frame >= it->Frame)
            {
                ++it;
                
                FromVec     = ToVec;
                FromIndex   = Frame;
                
                if (it != Keyframes.end())
                {
                    ToVec   = it->Vec;
                    ToIndex = it->Frame + 1;
                }
                else
                    ToIndex = Frame + 1;
            }
        }
        
        /* === Members === */
        
        //std::vector<Transformation> Keyframes_;
        std::vector<bool> RootKeyframes_;               
        
        #if 1 //!!!
        
        std::vector<SKeyPos> ConstructKeysPos_;
        std::vector<SKeyRot> ConstructKeysRot_;
        std::vector<SKeyScl> ConstructKeysScl_;
        
        std::vector<Transformation> Keyframes_;
        
        u32 MinFrame_, MaxFrame_;
        
        bool Modified_;
        bool UpdateImmediate_;
        
        #endif
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================