OgreAnimationTrack.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/

#ifndef __AnimationTrack_H__
#define __AnimationTrack_H__

#include "OgrePrerequisites.h"
#include "OgreSimpleSpline.h"
#include "OgreRotationalSpline.h"
#include "OgreKeyFrame.h"
#include "OgreAnimable.h"
#include "OgrePose.h"

namespace Ogre 
{
    class _OgreExport TimeIndex
    {
    protected:
        Real mTimePos;
        uint mKeyIndex;

        static const uint INVALID_KEY_INDEX = (uint)-1;

    public:
        TimeIndex(Real timePos)
            : mTimePos(timePos)
            , mKeyIndex(INVALID_KEY_INDEX)
        {
        }

        TimeIndex(Real timePos, uint keyIndex)
            : mTimePos(timePos)
            , mKeyIndex(keyIndex)
        {
        }

        bool hasKeyIndex(void) const
        {
            return mKeyIndex != INVALID_KEY_INDEX;
        }

        Real getTimePos(void) const
        {
            return mTimePos;
        }

        uint getKeyIndex(void) const
        {
            return mKeyIndex;
        }
    };

    class _OgreExport AnimationTrack : public AnimationAlloc
    {
    public:

        class _OgreExport Listener
        {
        public:
            virtual ~Listener() {}

            virtual bool getInterpolatedKeyFrame(const AnimationTrack* t, const TimeIndex& timeIndex, KeyFrame* kf) = 0;
        };

        AnimationTrack(Animation* parent, unsigned short handle);

        virtual ~AnimationTrack();

        unsigned short getHandle(void) const { return mHandle; }

        virtual unsigned short getNumKeyFrames(void) const;

        virtual KeyFrame* getKeyFrame(unsigned short index) const;

        virtual Real getKeyFramesAtTime(const TimeIndex& timeIndex, KeyFrame** keyFrame1, KeyFrame** keyFrame2,
            unsigned short* firstKeyIndex = 0) const;

        virtual KeyFrame* createKeyFrame(Real timePos);

        virtual void removeKeyFrame(unsigned short index);

        virtual void removeAllKeyFrames(void);


        virtual void getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf) const = 0;

        virtual void apply(const TimeIndex& timeIndex, Real weight = 1.0, Real scale = 1.0f) = 0;

        virtual void _keyFrameDataChanged(void) const {}

        virtual bool hasNonZeroKeyFrames(void) const { return true; }

        virtual void optimise(void) {}

        virtual void _collectKeyFrameTimes(vector<Real>::type& keyFrameTimes);

        virtual void _buildKeyFrameIndexMap(const vector<Real>::type& keyFrameTimes);
        
        virtual void _applyBaseKeyFrame(const KeyFrame* base) {}

        virtual void setListener(Listener* l) { mListener = l; }

        Animation *getParent() const { return mParent; }
    protected:
        typedef vector<KeyFrame*>::type KeyFrameList;
        KeyFrameList mKeyFrames;
        Animation* mParent;
        unsigned short mHandle;
        Listener* mListener;

        typedef vector<ushort>::type KeyFrameIndexMap;
        KeyFrameIndexMap mKeyFrameIndexMap;

        virtual KeyFrame* createKeyFrameImpl(Real time) = 0;

        virtual void populateClone(AnimationTrack* clone) const;
        


    };

    class _OgreExport NumericAnimationTrack : public AnimationTrack
    {
    public:
        NumericAnimationTrack(Animation* parent, unsigned short handle);
        NumericAnimationTrack(Animation* parent, unsigned short handle, 
            AnimableValuePtr& target);

        virtual NumericKeyFrame* createNumericKeyFrame(Real timePos);

        virtual void getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf) const;

        virtual void apply(const TimeIndex& timeIndex, Real weight = 1.0, Real scale = 1.0f);

        void applyToAnimable(const AnimableValuePtr& anim, const TimeIndex& timeIndex, 
            Real weight = 1.0, Real scale = 1.0f);

        virtual const AnimableValuePtr& getAssociatedAnimable(void) const;

        virtual void setAssociatedAnimable(const AnimableValuePtr& val);

        NumericKeyFrame* getNumericKeyFrame(unsigned short index) const;

        NumericAnimationTrack* _clone(Animation* newParent) const;


    protected:
        AnimableValuePtr mTargetAnim;

        KeyFrame* createKeyFrameImpl(Real time);


    };

    class _OgreExport NodeAnimationTrack : public AnimationTrack
    {
    public:
        NodeAnimationTrack(Animation* parent, unsigned short handle);
        NodeAnimationTrack(Animation* parent, unsigned short handle, 
            Node* targetNode);
        virtual ~NodeAnimationTrack();
        virtual TransformKeyFrame* createNodeKeyFrame(Real timePos);
        virtual Node* getAssociatedNode(void) const;

        virtual void setAssociatedNode(Node* node);

        virtual void applyToNode(Node* node, const TimeIndex& timeIndex, Real weight = 1.0, 
            Real scale = 1.0f);

        virtual void setUseShortestRotationPath(bool useShortestPath);

        virtual bool getUseShortestRotationPath() const;

        virtual void getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf) const;

        virtual void apply(const TimeIndex& timeIndex, Real weight = 1.0, Real scale = 1.0f);

        void _keyFrameDataChanged(void) const;

        virtual TransformKeyFrame* getNodeKeyFrame(unsigned short index) const;


        virtual bool hasNonZeroKeyFrames(void) const;

        virtual void optimise(void);

        NodeAnimationTrack* _clone(Animation* newParent) const;
        
        void _applyBaseKeyFrame(const KeyFrame* base);
        
    protected:
        KeyFrame* createKeyFrameImpl(Real time);
        // Flag indicating we need to rebuild the splines next time
        virtual void buildInterpolationSplines(void) const;

        // Struct for store splines, allocate on demand for better memory footprint
        struct Splines
        {
            SimpleSpline positionSpline;
            SimpleSpline scaleSpline;
            RotationalSpline rotationSpline;
        };

        Node* mTargetNode;
        // Prebuilt splines, must be mutable since lazy-update in const method
        mutable Splines* mSplines;
        mutable bool mSplineBuildNeeded;
        mutable bool mUseShortestRotationPath ;
    };

    enum VertexAnimationType
    {
        VAT_NONE = 0,
        VAT_MORPH = 1,
        VAT_POSE = 2
    };

    class _OgreExport VertexAnimationTrack : public AnimationTrack
    {
    public:
        enum TargetMode
        {
            TM_SOFTWARE, 
            TM_HARDWARE
        };
        VertexAnimationTrack(Animation* parent, unsigned short handle, VertexAnimationType animType);
        VertexAnimationTrack(Animation* parent, unsigned short handle, VertexAnimationType animType, 
            VertexData* targetData, TargetMode target = TM_SOFTWARE);

        VertexAnimationType getAnimationType(void) const { return mAnimationType; }
        
        bool getVertexAnimationIncludesNormals() const;

        virtual VertexMorphKeyFrame* createVertexMorphKeyFrame(Real timePos);

        virtual VertexPoseKeyFrame* createVertexPoseKeyFrame(Real timePos);

        virtual void getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf) const;

        virtual void apply(const TimeIndex& timeIndex, Real weight = 1.0, Real scale = 1.0f);

        virtual void applyToVertexData(VertexData* data, 
            const TimeIndex& timeIndex, Real weight = 1.0, 
            const PoseList* poseList = 0);


        VertexMorphKeyFrame* getVertexMorphKeyFrame(unsigned short index) const;

        VertexPoseKeyFrame* getVertexPoseKeyFrame(unsigned short index) const;

        void setAssociatedVertexData(VertexData* data) { mTargetVertexData = data; }
        VertexData* getAssociatedVertexData(void) const { return mTargetVertexData; }

        void setTargetMode(TargetMode m) { mTargetMode = m; }
        TargetMode getTargetMode(void) const { return mTargetMode; }

        virtual bool hasNonZeroKeyFrames(void) const;

        virtual void optimise(void);

        VertexAnimationTrack* _clone(Animation* newParent) const;
        
        void _applyBaseKeyFrame(const KeyFrame* base);

    protected:
        VertexAnimationType mAnimationType;
        VertexData* mTargetVertexData;
        TargetMode mTargetMode;

        KeyFrame* createKeyFrameImpl(Real time);

        void applyPoseToVertexData(const Pose* pose, VertexData* data, Real influence);


    };
}

#endif