Ogre::Animation相关类

Ogre实现动画的基本原理是：通过多个关键帧（KeyFrame）组成一个动画轨迹（AnimationTrack），多个动画轨迹组成一个动画。在各个关键帧之间通过插值算法（Spline插值或者线性插值）进行插值来生成最终的动画。一个动画不仅仅包含关键帧，还有其它的一些属性（动画名、动画长度、动画的权重、是否被启用等等）。一个动画轨迹可以指定其控制的节点。

OGRE中与基本动画相关的类

根据动画原理我们可以抽象出下面的几个类（动画状态\动画类\动画轨迹（由关键帧、简单插值和角度插值组成）：

SimpleSpline与RotationSpline类：

实现了样条的插值算法。SimpleSpline用来对Translate和Scale进行插值，RotationSpline用来对Rotation进行插值。

关键帧（KeyFrame）类：

组成动画最基本的元素，一个动画轨迹里面有多个关键帧，每个关键帧具有自己的位置、缩放比例和旋转角，同时每个关键帧还保存有自己在整个动画轨迹里所处的时间点。在实际运行时，根据当前时间，通过对两个关键帧的插值可以得到当前帧（当前位置、缩放比例和旋转角）。随着时间的变化，插值得到的当前帧也是变化的，动画就产生了。由于关键帧包括位置信息、缩放比例信息和旋转信息，所以可以实现运动动画、缩放动画和旋转动画以及混合动画。

通过观察下面的代码明显可以看出，Ogre中大量使用工厂模式的痕迹，用KeyFrame为基类，继承产生了以下的不同用途的五个关键帧类：

 

1． 关键帧类（KeyFrame类，所有下面的关键帧类的基础类）：

 

 class_OgreExport KeyFrame : public AnimationAlloc

 { //关键帧类

 public:

 KeyFrame(const AnimationTrack* parent, Real time);
 //构造函数，应该是被AnimationTrack类的createKeyFrame方法来调用而不是直接产生的virtual ~KeyFrame() {}

 Real getTime(void)const { return mTime; }

 virtual KeyFrame* _clone(AnimationTrack* newParent)const;

 protected: //--------------------------一个关键帧中有时间（在动作轨迹中）和其所属的动作序列的指针

 Real mTime;

 const AnimationTrack* mParentTrack;

 };

 

2. 数值关键帧类（MunmericKeyFrame类，里面存储了数值）

 class_OgreExport NumericKeyFrame :public KeyFrame

 {//------------------------数值关键帧类，里面存储了数值

 public:

 NumericKeyFrame(const AnimationTrack* parent, Real time);

 ~NumericKeyFrame() {}

 virtualconst AnyNumeric& getValue(void)const;

 virtualvoid setValue(const AnyNumeric& val);

 KeyFrame* _clone(AnimationTrack* newParent)const;

 protected:

 AnyNumeric mValue;

 };

 

3. 变换关键帧类（TransformKeyFrame）:其中存储了一个完整的该帧的数学变换

  

 class _OgreExport TransformKeyFrame :public KeyFrame

 {//变换关键帧：其中存储了一个完整的帧变换

 public:

 TransformKeyFrame(const AnimationTrack* parent, Real time);

 ~TransformKeyFrame() {}

 virtualvoid setTranslate(const Vector3& trans);

 //-----------------设置这个帧中的平移变换（用一个三维向量表示

 const Vector3& getTranslate(void)const;

 virtualvoid setScale(const Vector3& scale);

 //----------------用三维向量表示的此帧的缩放

 virtualconst Vector3& getScale(void)const;

 virtualvoid setRotation(const Quaternion& rot);

 //-----------------用四元数表示的此帧的旋转

 virtualconst Quaternion& getRotation(void)const;

 KeyFrame* _clone(AnimationTrack* newParent)const;

 protected:

 Vector3 mTranslate;

 Vector3 mScale;

 Quaternion mRotate;

 };

4. 点Morph关键帧类：存储了在一个完整缓存中点的绝对位置

 class _OgreExport VertexMorphKeyFrame :public KeyFrame

 { //点morph关键帧：存储了在一个完整缓存中点的绝对位置，用来在相同的动作轨迹中进行插值。

 public:

 VertexMorphKeyFrame(const AnimationTrack* parent, Real time);

 ~VertexMorphKeyFrame() {}

 void setVertexBuffer(const HardwareVertexBufferSharedPtr& buf);

 //为当前帧设置点缓存，我们假设在位置来源中的前3个位置是这帧的位置

 const HardwareVertexBufferSharedPtr& getVertexBuffer(void)const;

 KeyFrame* _clone(AnimationTrack* newParent)const;

 protected:

 HardwareVertexBufferSharedPtr mBuffer;

 };

5. 动作点关键帧类：在使用Mesh的情况下存储vertex偏移量

 class _OgreExport VertexPoseKeyFrame :public KeyFrame

 {//点位置帧：因为使用mesh产生的动作，其内部存储了指定的影响级别（大概是mesh受点位置变化的影响程度）下该帧的偏移

 public:

 VertexPoseKeyFrame(const AnimationTrack* parent, Real time);

 ~VertexPoseKeyFrame() {}

 struct PoseRef//----------------参考的动作

 {

 ushort poseIndex;

 //------------------------动作索引（短整型）

 Real influence;

 PoseRef(ushort p, Real i) : poseIndex(p), influence(i) {}

 };

 typedef vector<PoseRef>::type PoseRefList;

 void addPoseReference(ushort poseIndex, Real influence);

 void updatePoseReference(ushort poseIndex, Real influence);

 void removePoseReference(ushort poseIndex);

 void removeAllPoseReferences(void);

 const PoseRefList& getPoseReferences(void)const;

 typedef VectorIterator<PoseRefList> PoseRefIterator;

 typedef ConstVectorIterator<PoseRefList> ConstPoseRefIterator;

 PoseRefIterator getPoseReferenceIterator(void);

 ConstPoseRefIterator getPoseReferenceIterator(void)const;

 KeyFrame* _clone(AnimationTrack* newParent) const;

 protected:

 PoseRefList mPoseRefs;

 };

PS：以上关键帧的创建均通过AnimationTrack::createKeyFrame（）来完成，由此看继承机制真是个好东西

动画轨迹（AnimationTrack）类

 

动画轨迹由多个关键帧组成，负责对响铃的两个关键帧之间插值。

每个动画轨迹保存关键帧列表、本动画轨迹所属的动画（Animation）、本动画轨迹所控制的Node，又由于动画轨迹负责关键帧的插值，所以它保存SimpleSpline的（简单样条插值计算器）和RotationSpline（旋转样条插值计算器）对象以实现其插值功能。

一个动画轨迹可以对一个物体产生作用，使物体按照动画轨迹运动。这个物体可以是一个Node（一块骨头或者场景中的一个接点）。如有骨头受动画轨迹控制，可以实现骨骼动画.如果场景节点受到动画轨迹控制，可以直接实现场景节点的动画运动。

重要函数：

1） 创建一个关键帧，传入这一帧所在的时间点：

KeyFrame *createKeyFrame(Real timePos);

2） 根据当前时间，得到插值计算出来的当前帧

KeyFrame getInterpolatedKeyFrame(Real timeIndex)const

3） 使用当前动画轨迹对其控制的节点产生作用，参数是当前时间点、权重和是否累计权重

Void apply（Real timePos,Real weight=1.0,bool accumulate=false）

主要构成类：

构成方式和KeyFrame类如出一辙，即使用了动画轨迹（AnimationTrack）类作为基类，构造了如下的几个类：

 

A．动作轨迹（AnimationTrack）类：一个“轨迹“是指一个动作序列，因为最普通的可动作物体是节点Node，所以当”apply“方法被使用的时候会自动的实现帧的更新

 class_OgreExport AnimationTrack :public AnimationAlloc

 {//-----------------一个“轨迹”是指一个动作序列,因为最普遍的可动作物体是节点Node，所以当“apply”方法被使用的时候会自动的实现帧的更新

 public:

 class _OgreExport Listener

 { //----------------------------监听类，使用这个类可以允许你重写一个确定的运动轨迹

 public:

 virtual ~Listener() {}

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

 };

 /// Constructor

 AnimationTrack(Animation* parent,unsigned short handle);

 virtual ~AnimationTrack();

 unsignedshort getHandle(void)const { return mHandle; }

 //得到轨迹相关的句柄

 virtualunsigned short getNumKeyFrames(void)const;

 //得到这个动作轨迹中的帧数

 virtual KeyFrame* getKeyFrame(unsignedshort index) const;

 //通过特定索引来得到动画中的帧

 virtual Real getKeyFramesAtTime(const TimeIndex& timeIndex, KeyFrame** keyFrame1, KeyFrame** keyFrame2,

 unsignedshort* firstKeyIndex = 0) const;

 //-------------------------------返回介于KeyFrame1和KeyFrame2之间的帧，timeIndex是用于两帧之间时间标记，keyFrame1和KeyFrame2分别是用来构造新帧的帧模板，最后一个参数指向了形成的帧

 virtual KeyFrame* createKeyFrame(Real timePos);

 virtualvoid removeKeyFrame(unsignedshort index);

 virtual void removeAllKeyFrames(void);

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

 //得到在timeIndex上的插值帧

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

 //-----------------在特定的目标上面使用该动作轨迹

 virtual void _keyFrameDataChanged(void) const {}

   //-------------------告知关键帧已经改变

 virtualbool hasNonZeroKeyFrames(void)const { return true; }

 //-------------------使用这个函数来说明是否这个序列中有可用帧

 virtualvoid optimise(void) {}

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

 //----------------使用一个关键帧时间序列来定义特殊的帧轨迹

 virtualvoid _buildKeyFrameIndexMap(const vector<Real>::type& keyFrameTimes);

 //----------------通过定义一个关键帧时间序列来完成关键帧映射动画的建立

 virtualvoid setListener(Listener* l) { mListener = l; }

 Animation *getParent() const { return mParent; }



 protected:

 typedef vector<KeyFrame*>::type KeyFrameList;

 KeyFrameList mKeyFrames;

 Animation* mParent;

 unsignedshort mHandle;

 Listener* mListener;

 /// Map used to translate global keyframe time lower bound index to local lower bound index

 typedef vector<ushort>::type KeyFrameIndexMap;

 KeyFrameIndexMap mKeyFrameIndexMap;

 /// Create a keyframe implementation - must be overridden

 virtual KeyFrame* createKeyFrameImpl(Real time) = 0;

 /// Internal method for clone implementation

 virtualvoid populateClone(AnimationTrack* clone) const;

 };

 

B. 数值动作轨迹（NumericAnimationTrack）类：通过处理一般的动作数值来完成动作轨迹的建立（由上面提到的数值关键帧（NumeraicKeyFrame）来构成）

 

 class_OgreExport NumericAnimationTrack :public AnimationTrack

 { //数值动作轨迹：通过处理一般的动作数值来完成动作轨迹的建立

 public:

 /// Constructor

 NumericAnimationTrack(Animation* parent,unsigned short handle);

 /// Constructor, associates with an AnimableValue

 NumericAnimationTrack(Animation* parent,unsigned short handle,

 AnimableValuePtr& target);

 virtual NumericKeyFrame* createNumericKeyFrame(Real timePos);

 //由数值关键帧构成

 /// @copydoc AnimationTrack::getInterpolatedKeyFrame

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

 /// @copydoc AnimationTrack::apply

 virtualvoid 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;

 virtualvoid setAssociatedAnimable(const AnimableValuePtr& val);

 NumericKeyFrame* getNumericKeyFrame(unsignedshort index) const;

 NumericAnimationTrack* _clone(Animation* newParent)const;



 protected:

 /// Target to animate

 AnimableValuePtr mTargetAnim;

 /// @copydoc AnimationTrack::createKeyFrameImpl

 KeyFrame* createKeyFrameImpl(Real time);

 };

C. 节点动作轨迹（NodeAnimationTrack）类：主要是处理以节点为目标帧变换

 

 class_OgreExport NodeAnimationTrack :public AnimationTrack

 { //---------------------结点动作轨迹

 public:

 /// Constructor

 NodeAnimationTrack(Animation* parent,unsigned short handle);

 /// Constructor, associates with a Node

 NodeAnimationTrack(Animation* parent,unsigned short handle,

 Node* targetNode);

 /// Destructor

 virtual ~NodeAnimationTrack();

 virtual TransformKeyFrame* createNodeKeyFrame(Real timePos);

 virtual Node* getAssociatedNode(void)const;

 virtualvoid setAssociatedNode(Node* node);

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

 virtualvoid setUseShortestRotationPath(bool useShortestPath);

 virtualbool getUseShortestRotationPath() const;

 /// @copydoc AnimationTrack::getInterpolatedKeyFrame

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

 /// @copydoc AnimationTrack::apply

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

 /// @copydoc AnimationTrack::_keyFrameDataChanged

 void _keyFrameDataChanged(void)const;

 virtual TransformKeyFrame* getNodeKeyFrame(unsignedshort index) const;

 virtualbool hasNonZeroKeyFrames(void)const;

 virtualvoid optimise(void);

 NodeAnimationTrack* _clone(Animation* newParent)const;

 protected:

 /// Specialised keyframe creation

 KeyFrame* createKeyFrameImpl(Real time);

 // Flag indicating we need to rebuild the splines next time

 virtualvoid 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;

 mutablebool mSplineBuildNeeded;

 /// Defines if rotation is done using shortest path

 mutablebool mUseShortestRotationPath ;

 };

D. 顶点动作轨迹（VertexAnimationTrack）类：用来处理变化顶点信息的类

 class_OgreExport VertexAnimationTrack :public AnimationTrack

 {//----------------------------顶点动作轨迹

 public:

 enum TargetMode

 {

 /// Interpolate vertex positions in software

 TM_SOFTWARE,

 TM_HARDWARE

 };

 /// Constructor

 VertexAnimationTrack(Animation* parent,unsigned short handle, VertexAnimationType animType);

 /// Constructor, associates with target VertexData and temp buffer (for software)

 VertexAnimationTrack(Animation* parent,unsigned short handle, VertexAnimationType animType,

 VertexData* targetData, TargetMode target = TM_SOFTWARE);

 VertexAnimationType getAnimationType(void)const { return mAnimationType; }

 virtual VertexMorphKeyFrame* createVertexMorphKeyFrame(Real timePos);

 virtual VertexPoseKeyFrame* createVertexPoseKeyFrame(Real timePos);

 virtualvoid getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf)const

 { (void)timeIndex; (void)kf; }



 /// @copydoc AnimationTrack::apply

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

 virtualvoid applyToVertexData(VertexData* data,

 const TimeIndex& timeIndex, Real weight = 1.0,

 const PoseList* poseList = 0);



 VertexMorphKeyFrame* getVertexMorphKeyFrame(unsignedshort index) const;

 VertexPoseKeyFrame* getVertexPoseKeyFrame(unsignedshort index) const;

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

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



 /// Set the target mode

 void setTargetMode(TargetMode m) { mTargetMode = m; }

 /// Get the target mode

 TargetMode getTargetMode(void)const { return mTargetMode; }

 virtualbool hasNonZeroKeyFrames(void)const;

 virtualvoid optimise(void);

 VertexAnimationTrack* _clone(Animation* newParent)const;



 protected:

 /// Animation type

 VertexAnimationType mAnimationType;

   /// Target to animate

 VertexData* mTargetVertexData;

 /// Mode to apply

 TargetMode mTargetMode;



 /// @copydoc AnimationTrack::createKeyFrameImpl

 KeyFrame* createKeyFrameImpl(Real time);

 /// Utility method for applying pose animation

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

 };

 

 

动画类（Animation）

 

一个动画由多个动画轨迹（AnimationTrack）组成，而一个动画轨迹可以控制一个节点，这样一个动画可以使得多个节点沿着自己的轨迹运动。

设想一下一个人的行走动画，人身上的关节点都沿着自己的轨迹运动，如果把两个关节点连接起来，就形成骨头，再让表面的网格受骨头影响而运动，骨骼动画的基础就有了！

每个动画保存子阿吉的AnimationTrack列表，保存动画名称和长度（时间）。

重要函数

1） 设置关键帧间的插值方式。参数IM_LNEAR代表线性插值、IM_SPLINE代表样条插值；

Void setInterpolationMode（InterpolationMode im）

2） 创建一个动画轨迹，第一个参数是这个动画轨迹的唯一标识，第二个参数指定应用这个动画轨迹的节点

AnimationTrack *createTrack(unsigned shor handle,Node *node);

3） 使得当前动画对其控制的节点产生作用（委托AnimationTrack进行），参数是当前时间点、权重和是否累计权重。

Void apply（Real timePos，Real weight=1.0，bool accumulate=false）

(具体的各种函数可以在OgreAnimation.h中看到)

动画状态类（AnimationState）

一个动画状态类的对象对应一个动画类的对象，看上面的类图，AnimationState的数据成员mAnimationName与Animation类的数据成员没Name是相对应的，它保存相应动画的状态。

动画状态包括动画名、当前时间点，动画长度（总时间）、动画权重和动画的Enable开关

重要函数

1） 设置动画是否可用

Void setEnabled(bool enabled);

2） 移动当前时间点，让动画状态在动画时间线上向前移动，参数为移动量。

Void addTime(Real offset) 

场景管理器（SceneManager）类： 

场景管理器负责动画和动画状态的创建于维护，在场景管理器中保存有没AnimationList（动画列表）和没Animation（动画状态列表），其中每个动画和动画状态通过名字一一对应。

场景管理器中有一个很重要的方法_applySceneAnimations.在每次渲染时（_renderScene函数里）都会被调用（自动调用不需要程序员控制），它的任务是在每一帧渲染之前根据动画状态更新动画，完成动作。_applySceneAnimation方法遍历全部的动画状态，并根据这些状态找出与之一一对应的动画。再找出每个动画中的全部动画轨迹，在每个轨迹里都保存有该轨迹控制的节点。_applySceneAnimations方法首先将这些被动画控制额节点都还原为初始状态，而后载调用动画的apply方法将全部节点更新到新的位置、大小或者方向，从而使得动画向前进行。

重要函数

1) 创建动画Animation，参数为动画名和长度（时间）

Virtual Animation *createAnimation（const string &name，Real length）

2） 创建动画状态AnimationState，参数是与动画对应的名称

Virtual AnimationState *createAnimationState（const String&animationName）

Ogre的骨骼动画： 

骨骼动画用骨架（由一系列骨头构成的继承体系）来单独保存动作信息，这样就将动作信息与网络、皮肤信息分割成两种数据结构分别进行处理，从而比以往的动画技术效率更高。每块骨头都有自己的位置和旋转方向，这些骨头以树的形式组织起来构成骨骼。例如：腕关节是肘关节的子节点，肘关节又是肩关节的子节点。肩关节旋转会自动带动肘关节运动，腕关节同样也会运动。

怎样使得一个网格产生动作效果？我们可以使网格上的每个顶点都对应于一块或多块骨头，当这些骨头移动时便会影响网格的位置。如果一个点与多块骨头关联，则必须通过指定权重类决定每块骨头对此顶点的影响程度（一个顶点对应一块骨头的时候，该点的权重为1.0）。

与关键帧动画相比，使用骨骼动画有很多优点。首先，骨骼动画需要保存的动作数据量非常小。其次，通过指定不同的权重，可以很容易的将多个动作绑定在一起形成新的动作。还可以实现动作键的平滑过渡等等。

当然骨骼动画的实现中，骨骼本身的运动还是需要关键帧来完成，但是信息量已经很小了。

        Ogre骨骼信息和动画信息保存到后缀名为.skeleton的文件中，你可以通过OGRE提供的导出插件工具（Milkshape和3Dmax的exporter）来导出该类型的文件。当你创建基于Mesh文件的Entity的时候，.skeleton文件将会自动被系统加载进来。为了操作方便，Entity自动给每一个动作指定一个AnimationState类对象，可以通过Entity::getAnimationState函数来得到具体的动作。

上文来自：http://blog.csdn.net/kuangfengwu/article/details/7896841