OGRE  1.9.0
OgreAnimationTrack.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2014 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE SOFTWARE.
26-----------------------------------------------------------------------------
27*/
28
29#ifndef __AnimationTrack_H__
30#define __AnimationTrack_H__
31
32#include "OgrePrerequisites.h"
33#include "OgreSimpleSpline.h"
35#include "OgreKeyFrame.h"
36#include "OgreAnimable.h"
37#include "OgrePose.h"
38#include "OgreHeaderPrefix.h"
39
40namespace Ogre
41{
51 {
52 protected:
62
65 static const uint INVALID_KEY_INDEX = (uint)-1;
66
67 public:
70 TimeIndex(Real timePos)
71 : mTimePos(timePos)
72 , mKeyIndex(INVALID_KEY_INDEX)
73 {
74 }
75
81 TimeIndex(Real timePos, uint keyIndex)
82 : mTimePos(timePos)
83 , mKeyIndex(keyIndex)
84 {
85 }
86
87 bool hasKeyIndex(void) const
88 {
89 return mKeyIndex != INVALID_KEY_INDEX;
90 }
91
92 Real getTimePos(void) const
93 {
94 return mTimePos;
95 }
96
97 uint getKeyIndex(void) const
98 {
99 return mKeyIndex;
100 }
101 };
102
123 {
124 public:
125
130 {
131 public:
132 virtual ~Listener() {}
133
137 virtual bool getInterpolatedKeyFrame(const AnimationTrack* t, const TimeIndex& timeIndex, KeyFrame* kf) = 0;
138 };
139
141 AnimationTrack(Animation* parent, unsigned short handle);
142
144
146 unsigned short getHandle(void) const { return mHandle; }
147
149 virtual unsigned short getNumKeyFrames(void) const;
150
152 virtual KeyFrame* getKeyFrame(unsigned short index) const;
153
175 virtual Real getKeyFramesAtTime(const TimeIndex& timeIndex, KeyFrame** keyFrame1, KeyFrame** keyFrame2,
176 unsigned short* firstKeyIndex = 0) const;
177
185 virtual KeyFrame* createKeyFrame(Real timePos);
186
188 virtual void removeKeyFrame(unsigned short index);
189
191 virtual void removeAllKeyFrames(void);
192
193
203 virtual void getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf) const = 0;
204
212 virtual void apply(const TimeIndex& timeIndex, Real weight = 1.0, Real scale = 1.0f) = 0;
213
216 virtual void _keyFrameDataChanged(void) const {}
217
222 virtual bool hasNonZeroKeyFrames(void) const { return true; }
223
225 virtual void optimise(void) {}
226
228 virtual void _collectKeyFrameTimes(vector<Real>::type& keyFrameTimes);
229
232 virtual void _buildKeyFrameIndexMap(const vector<Real>::type& keyFrameTimes);
233
235 virtual void _applyBaseKeyFrame(const KeyFrame* base);
236
238 virtual void setListener(Listener* l) { mListener = l; }
239
241 Animation *getParent() const { return mParent; }
242 protected:
246 unsigned short mHandle;
248
252
254 virtual KeyFrame* createKeyFrameImpl(Real time) = 0;
255
257 virtual void populateClone(AnimationTrack* clone) const;
258
259
260
261 };
262
266 {
267 public:
269 NumericAnimationTrack(Animation* parent, unsigned short handle);
271 NumericAnimationTrack(Animation* parent, unsigned short handle,
272 AnimableValuePtr& target);
273
282
284 virtual void getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf) const;
285
287 virtual void apply(const TimeIndex& timeIndex, Real weight = 1.0, Real scale = 1.0f);
288
297 void applyToAnimable(const AnimableValuePtr& anim, const TimeIndex& timeIndex,
298 Real weight = 1.0, Real scale = 1.0f);
299
301 virtual const AnimableValuePtr& getAssociatedAnimable(void) const;
302
305 virtual void setAssociatedAnimable(const AnimableValuePtr& val);
306
308 NumericKeyFrame* getNumericKeyFrame(unsigned short index) const;
309
312
313
314 protected:
317
320
321
322 };
323
327 {
328 public:
330 NodeAnimationTrack(Animation* parent, unsigned short handle);
332 NodeAnimationTrack(Animation* parent, unsigned short handle,
333 Node* targetNode);
345 virtual Node* getAssociatedNode(void) const;
346
348 virtual void setAssociatedNode(Node* node);
349
351 virtual void applyToNode(Node* node, const TimeIndex& timeIndex, Real weight = 1.0,
352 Real scale = 1.0f);
353
355 virtual void setUseShortestRotationPath(bool useShortestPath);
356
358 virtual bool getUseShortestRotationPath() const;
359
361 virtual void getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf) const;
362
364 virtual void apply(const TimeIndex& timeIndex, Real weight = 1.0, Real scale = 1.0f);
365
367 void _keyFrameDataChanged(void) const;
368
370 virtual TransformKeyFrame* getNodeKeyFrame(unsigned short index) const;
371
372
377 virtual bool hasNonZeroKeyFrames(void) const;
378
380 virtual void optimise(void);
381
384
385 void _applyBaseKeyFrame(const KeyFrame* base);
386
387 protected:
390 // Flag indicating we need to rebuild the splines next time
391 virtual void buildInterpolationSplines(void) const;
392
393 // Struct for store splines, allocate on demand for better memory footprint
394 struct Splines
395 {
399 };
400
402 // Prebuilt splines, must be mutable since lazy-update in const method
404 mutable bool mSplineBuildNeeded;
407 };
408
468 {
474 VAT_POSE = 2
475 };
476
481 {
482 public:
485 {
490 TM_HARDWARE
491 };
493 VertexAnimationTrack(Animation* parent, unsigned short handle, VertexAnimationType animType);
495 VertexAnimationTrack(Animation* parent, unsigned short handle, VertexAnimationType animType,
496 VertexData* targetData, TargetMode target = TM_SOFTWARE);
497
499 VertexAnimationType getAnimationType(void) const { return mAnimationType; }
500
503
512
516
519 virtual void getInterpolatedKeyFrame(const TimeIndex& timeIndex, KeyFrame* kf) const;
520
522 virtual void apply(const TimeIndex& timeIndex, Real weight = 1.0, Real scale = 1.0f);
523
526 virtual void applyToVertexData(VertexData* data,
527 const TimeIndex& timeIndex, Real weight = 1.0,
528 const PoseList* poseList = 0);
529
530
532 VertexMorphKeyFrame* getVertexMorphKeyFrame(unsigned short index) const;
533
535 VertexPoseKeyFrame* getVertexPoseKeyFrame(unsigned short index) const;
536
538 void setAssociatedVertexData(VertexData* data) { mTargetVertexData = data; }
540 VertexData* getAssociatedVertexData(void) const { return mTargetVertexData; }
541
543 void setTargetMode(TargetMode m) { mTargetMode = m; }
545 TargetMode getTargetMode(void) const { return mTargetMode; }
546
551 virtual bool hasNonZeroKeyFrames(void) const;
552
554 virtual void optimise(void);
555
558
559 void _applyBaseKeyFrame(const KeyFrame* base);
560
561 protected:
568
571
573 void applyPoseToVertexData(const Pose* pose, VertexData* data, Real influence);
574
575
576 };
579}
580
581#include "OgreHeaderSuffix.h"
582
583#endif
#define _OgreExport
Definition: OgrePlatform.h:260
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Listener allowing you to override certain behaviour of a track, for example to drive animation proced...
virtual bool getInterpolatedKeyFrame(const AnimationTrack *t, const TimeIndex &timeIndex, KeyFrame *kf)=0
Get an interpolated keyframe for this track at the given time.
A 'track' in an animation sequence, i.e.
AnimationTrack(Animation *parent, unsigned short handle)
Constructor.
virtual void _keyFrameDataChanged(void) const
Internal method used to tell the track that keyframe data has been changed, which may cause it to reb...
virtual void populateClone(AnimationTrack *clone) const
Internal method for clone implementation.
virtual ~AnimationTrack()
KeyFrameIndexMap mKeyFrameIndexMap
unsigned short getHandle(void) const
Get the handle associated with this track.
vector< ushort >::type KeyFrameIndexMap
Map used to translate global keyframe time lower bound index to local lower bound index.
virtual unsigned short getNumKeyFrames(void) const
Returns the number of keyframes in this animation.
virtual KeyFrame * createKeyFrameImpl(Real time)=0
Create a keyframe implementation - must be overridden.
virtual Real getKeyFramesAtTime(const TimeIndex &timeIndex, KeyFrame **keyFrame1, KeyFrame **keyFrame2, unsigned short *firstKeyIndex=0) const
Gets the 2 KeyFrame objects which are active at the time given, and the blend value between them.
virtual void removeKeyFrame(unsigned short index)
Removes a KeyFrame by it's index.
virtual void getInterpolatedKeyFrame(const TimeIndex &timeIndex, KeyFrame *kf) const =0
Gets a KeyFrame object which contains the interpolated transforms at the time index specified.
virtual bool hasNonZeroKeyFrames(void) const
Method to determine if this track has any KeyFrames which are doing anything useful - can be used to ...
virtual void _collectKeyFrameTimes(vector< Real >::type &keyFrameTimes)
Internal method to collect keyframe times, in unique, ordered format.
virtual void apply(const TimeIndex &timeIndex, Real weight=1.0, Real scale=1.0f)=0
Applies an animation track to the designated target.
virtual KeyFrame * getKeyFrame(unsigned short index) const
Returns the KeyFrame at the specified index.
virtual void removeAllKeyFrames(void)
Removes all the KeyFrames from this track.
virtual void optimise(void)
Optimise the current track by removing any duplicate keyframes.
virtual void _applyBaseKeyFrame(const KeyFrame *base)
Internal method to re-base the keyframes relative to a given keyframe.
virtual void _buildKeyFrameIndexMap(const vector< Real >::type &keyFrameTimes)
Internal method to build keyframe time index map to translate global lower bound index to local lower...
virtual KeyFrame * createKeyFrame(Real timePos)
Creates a new KeyFrame and adds it to this animation at the given time index.
Animation * getParent() const
Returns the parent Animation object for this track.
virtual void setListener(Listener *l)
Set a listener for this track.
vector< KeyFrame * >::type KeyFrameList
An animation sequence.
Definition: OgreAnimation.h:93
A key frame in an animation sequence defined by an AnimationTrack.
Definition: OgreKeyFrame.h:57
Specialised AnimationTrack for dealing with node transforms.
virtual ~NodeAnimationTrack()
Destructor.
void _keyFrameDataChanged(void) const
Internal method used to tell the track that keyframe data has been changed, which may cause it to reb...
NodeAnimationTrack(Animation *parent, unsigned short handle)
Constructor.
virtual void applyToNode(Node *node, const TimeIndex &timeIndex, Real weight=1.0, Real scale=1.0f)
As the 'apply' method but applies to a specified Node instead of associated node.
virtual void buildInterpolationSplines(void) const
NodeAnimationTrack * _clone(Animation *newParent) const
Clone this track (internal use only)
virtual Node * getAssociatedNode(void) const
Returns a pointer to the associated Node object (if any).
virtual void setUseShortestRotationPath(bool useShortestPath)
Sets the method of rotation calculation.
bool mUseShortestRotationPath
Defines if rotation is done using shortest path.
virtual void apply(const TimeIndex &timeIndex, Real weight=1.0, Real scale=1.0f)
Applies an animation track to the designated target.
virtual TransformKeyFrame * createNodeKeyFrame(Real timePos)
Creates a new KeyFrame and adds it to this animation at the given time index.
virtual bool hasNonZeroKeyFrames(void) const
Method to determine if this track has any KeyFrames which are doing anything useful - can be used to ...
virtual void getInterpolatedKeyFrame(const TimeIndex &timeIndex, KeyFrame *kf) const
Gets a KeyFrame object which contains the interpolated transforms at the time index specified.
virtual TransformKeyFrame * getNodeKeyFrame(unsigned short index) const
Returns the KeyFrame at the specified index.
virtual void setAssociatedNode(Node *node)
Sets the associated Node object which will be automatically affected by calls to 'apply'.
virtual bool getUseShortestRotationPath() const
Gets the method of rotation calculation.
NodeAnimationTrack(Animation *parent, unsigned short handle, Node *targetNode)
Constructor, associates with a Node.
virtual void optimise(void)
Optimise the current track by removing any duplicate keyframes.
void _applyBaseKeyFrame(const KeyFrame *base)
Internal method to re-base the keyframes relative to a given keyframe.
KeyFrame * createKeyFrameImpl(Real time)
Specialised keyframe creation.
Class representing a general-purpose node an articulated scene graph.
Definition: OgreNode.h:65
Specialised AnimationTrack for dealing with generic animable values.
NumericAnimationTrack * _clone(Animation *newParent) const
Clone this track (internal use only)
NumericAnimationTrack(Animation *parent, unsigned short handle)
Constructor.
void applyToAnimable(const AnimableValuePtr &anim, const TimeIndex &timeIndex, Real weight=1.0, Real scale=1.0f)
Applies an animation track to a given animable value.
NumericAnimationTrack(Animation *parent, unsigned short handle, AnimableValuePtr &target)
Constructor, associates with an AnimableValue.
KeyFrame * createKeyFrameImpl(Real time)
Create a keyframe implementation - must be overridden.
virtual void setAssociatedAnimable(const AnimableValuePtr &val)
Sets the associated animable object which will be automatically affected by calls to 'apply'.
AnimableValuePtr mTargetAnim
Target to animate.
virtual const AnimableValuePtr & getAssociatedAnimable(void) const
Returns a pointer to the associated animable object (if any).
virtual void apply(const TimeIndex &timeIndex, Real weight=1.0, Real scale=1.0f)
Applies an animation track to the designated target.
virtual void getInterpolatedKeyFrame(const TimeIndex &timeIndex, KeyFrame *kf) const
Gets a KeyFrame object which contains the interpolated transforms at the time index specified.
NumericKeyFrame * getNumericKeyFrame(unsigned short index) const
Returns the KeyFrame at the specified index.
virtual NumericKeyFrame * createNumericKeyFrame(Real timePos)
Creates a new KeyFrame and adds it to this animation at the given time index.
Specialised KeyFrame which stores any numeric value.
Definition: OgreKeyFrame.h:81
A pose is a linked set of vertex offsets applying to one set of vertex data.
Definition: OgrePose.h:56
This class interpolates orientations (rotations) along a spline using derivatives of quaternions.
A very simple spline class which implements the Catmull-Rom class of splines.
Time index object used to search keyframe at the given position.
Real getTimePos(void) const
uint mKeyIndex
The global keyframe index (in relation to the whole animation sequence) that used to convert to local...
uint getKeyIndex(void) const
TimeIndex(Real timePos, uint keyIndex)
Construct time index object by the given time position and global keyframe index.
Real mTimePos
The time position (in relation to the whole animation sequence)
TimeIndex(Real timePos)
Construct time index object by the given time position.
bool hasKeyIndex(void) const
Specialised KeyFrame which stores a full transform.
Definition: OgreKeyFrame.h:104
Specialised AnimationTrack for dealing with changing vertex position information.
VertexAnimationTrack(Animation *parent, unsigned short handle, VertexAnimationType animType)
Constructor.
virtual void apply(const TimeIndex &timeIndex, Real weight=1.0, Real scale=1.0f)
Applies an animation track to the designated target.
VertexData * mTargetVertexData
Target to animate.
VertexData * getAssociatedVertexData(void) const
Gets the associated VertexData which this track will update.
virtual VertexPoseKeyFrame * createVertexPoseKeyFrame(Real timePos)
Creates the single pose KeyFrame and adds it to this animation.
VertexPoseKeyFrame * getVertexPoseKeyFrame(unsigned short index) const
Returns the pose KeyFrame at the specified index.
VertexMorphKeyFrame * getVertexMorphKeyFrame(unsigned short index) const
Returns the morph KeyFrame at the specified index.
VertexAnimationTrack * _clone(Animation *newParent) const
Clone this track (internal use only)
virtual void applyToVertexData(VertexData *data, const TimeIndex &timeIndex, Real weight=1.0, const PoseList *poseList=0)
As the 'apply' method but applies to specified VertexData instead of associated data.
VertexAnimationType mAnimationType
Animation type.
virtual void optimise(void)
Optimise the current track by removing any duplicate keyframes.
TargetMode getTargetMode(void) const
Get the target mode.
void _applyBaseKeyFrame(const KeyFrame *base)
Internal method to re-base the keyframes relative to a given keyframe.
TargetMode mTargetMode
Mode to apply.
VertexAnimationType getAnimationType(void) const
Get the type of vertex animation we're performing.
TargetMode
The target animation mode.
@ TM_SOFTWARE
Interpolate vertex positions in software.
virtual VertexMorphKeyFrame * createVertexMorphKeyFrame(Real timePos)
Creates a new morph KeyFrame and adds it to this animation at the given time index.
void applyPoseToVertexData(const Pose *pose, VertexData *data, Real influence)
Utility method for applying pose animation.
void setAssociatedVertexData(VertexData *data)
Sets the associated VertexData which this track will update.
virtual bool hasNonZeroKeyFrames(void) const
Method to determine if this track has any KeyFrames which are doing anything useful - can be used to ...
virtual void getInterpolatedKeyFrame(const TimeIndex &timeIndex, KeyFrame *kf) const
Gets a KeyFrame object which contains the interpolated transforms at the time index specified.
void setTargetMode(TargetMode m)
Set the target mode.
VertexAnimationTrack(Animation *parent, unsigned short handle, VertexAnimationType animType, VertexData *targetData, TargetMode target=TM_SOFTWARE)
Constructor, associates with target VertexData and temp buffer (for software)
bool getVertexAnimationIncludesNormals() const
Whether the vertex animation (if present) includes normals.
KeyFrame * createKeyFrameImpl(Real time)
Create a keyframe implementation - must be overridden.
Summary class collecting together vertex source information.
Specialised KeyFrame which stores absolute vertex positions for a complete buffer,...
Definition: OgreKeyFrame.h:155
Specialised KeyFrame which references a Mesh::Pose at a certain influence level, which stores offsets...
Definition: OgreKeyFrame.h:185
vector< Pose * >::type PoseList
Definition: OgrePose.h:135
VertexAnimationType
Type of vertex animation.
@ VAT_MORPH
Morph animation is made up of many interpolated snapshot keyframes.
@ VAT_POSE
Pose animation is made up of a single delta pose keyframe.
@ VAT_NONE
No animation.
float Real
Software floating point type.
unsigned int uint
std::vector< T, A > type