SLAnimTrack Class Reference

Abstract base class for SLAnimationTracks providing time and keyframe functions. More...

#include <SLAnimTrack.h>

Inheritance diagram for SLAnimTrack:

Public Member Functions
	SLAnimTrack (SLAnimation *parent)
virtual	~SLAnimTrack ()
SLAnimKeyframe *	createKeyframe (SLfloat time)
SLfloat	getKeyframesAtTime (SLfloat time, SLAnimKeyframe **k1, SLAnimKeyframe **k2) const
virtual void	calcInterpolatedKeyframe (SLfloat time, SLAnimKeyframe *keyframe) const =0
virtual void	apply (SLfloat time, SLfloat weight=1.0f, SLfloat scale=1.0f)=0
virtual void	drawVisuals (SLSceneView *sv)=0
SLint	numKeyframes () const
SLAnimKeyframe *	keyframe (SLint index)

Protected Member Functions
virtual SLAnimKeyframe *	createKeyframeImpl (SLfloat time)=0
	Keyframe creator function for derived implementations. More...

Protected Attributes
SLAnimation *	_animation
	parent animation that created this track More...
SLVKeyframe	_keyframes
	keyframe list for this track More...

Detailed Description

Abstract base class for SLAnimationTracks providing time and keyframe functions.

An animation track is a specialized track that affects a single SLNode or an SLJoint of an SLAnimSkeleton by interpolating its transform. It holds therefore a list of SLKeyframe. For a smooth motion it can interpolate the transform at a given time between two neighboring SLKeyframe.

Definition at line 31 of file SLAnimTrack.h.

Constructor & Destructor Documentation

SLAnimTrack()

SLAnimTrack::SLAnimTrack

(

SLAnimation *

animation

)

Constructor

Definition at line 18 of file SLAnimTrack.cpp.

  : _animation(animation)
{
}

~SLAnimTrack()

SLAnimTrack::~SLAnimTrack ( )

virtual

Destructor

Definition at line 26 of file SLAnimTrack.cpp.

{
    for (auto kf : _keyframes)
        delete kf;
}

Member Function Documentation

apply()

virtual void SLAnimTrack::apply ( SLfloat  time, SLfloat  weight = 1.0f, SLfloat  scale = 1.0f  )

pure virtual

Implemented in SLNodeAnimTrack.

calcInterpolatedKeyframe()

virtual void SLAnimTrack::calcInterpolatedKeyframe ( SLfloat  time, SLAnimKeyframe *  keyframe  ) const

pure virtual

Implemented in SLNodeAnimTrack.

createKeyframe()

SLAnimKeyframe * SLAnimTrack::createKeyframe

(

SLfloat

time

)

Creates a new keyframed with the passed in timestamp.

Note

It is required that the keyframes are created in chronological order. since we currently don't sort the keyframe list they have to be sorted before being created.

Definition at line 38 of file SLAnimTrack.cpp.

{
    SLAnimKeyframe* kf = createKeyframeImpl(time);
    _keyframes.push_back(kf);
    return kf;
}

createKeyframeImpl()

virtual SLAnimKeyframe* SLAnimTrack::createKeyframeImpl ( SLfloat  time )

protectedpure virtual

Keyframe creator function for derived implementations.

Implemented in SLNodeAnimTrack.

drawVisuals()

virtual void SLAnimTrack::drawVisuals ( SLSceneView *  sv )

pure virtual

Implemented in SLNodeAnimTrack.

getKeyframesAtTime()

SLfloat SLAnimTrack::getKeyframesAtTime	(	SLfloat	time,
		SLAnimKeyframe **	k1,
		SLAnimKeyframe **	k2
	)		const

Get the two keyframes to the left or the right of the passed in timestamp. If keyframes will wrap around, if there is no keyframe after the passed in time then the k2 result will be the first keyframe in the list. If only one keyframe exists the two values will be equivalent.

Todo:

do we want to consider the edge case below or do we want imported animations to have to have a keyframe at 0.0 time? Is there a better solution for this problem? e.x: the astroboy animation looks wrong when doing this (but thats because it is **** and kf0 and kfn dont match up...

Definition at line 62 of file SLAnimTrack.cpp.

{
    SLfloat t1, t2;
    SLuint  numKf           = (SLuint)_keyframes.size();
    float   animationLength = _animation->lengthSec();
 
    assert(animationLength > 0.0f && "Animation length is invalid.");
 
    *k1 = *k2 = nullptr;
 
    // no keyframes or only one keyframe in animation, early out
    if (numKf == 0)
        return 0.0f;
 
    if (numKf < 2)
    {
        *k1 = *k2 = _keyframes[0];
        return 0.0f;
    }
 
    // wrap time
    if (time > animationLength)
        time = fmod(time, animationLength);
 
    // @todo is it really required of us to check if time is < 0.0f here? Or should this be done higher up?
    while (time < 0.0f)
        time += animationLength;
 
    // search lower bound kf for given time
    // kf list must be sorted by time at this point
    // @todo we could use std::lower_bounds here
    // @todo this could be implemented much nicer
    //      use the following algorithm:
    //      1. find the keyframe that comes after the 'time' parameter
    //      2. if there is no keyframe after 'time' then set keframe 2 to the first keyframe in the list
    //          set t2 to animationLength + the time of the keyframe
    //      3. if there is a keyframe after 'time' then set keyframe 2 to that keyframe
    //          set t2 to the time of the keyframe
    //      4. now find the keyframe before keyframe 2 (if we use iterators here this is trivial!)
    //         set keyframe 1 to the keyframe found before keyframe 2
    SLuint kfIndex = 0;
    for (SLuint i = 0; i < numKf; ++i)
    {
        SLAnimKeyframe* cur = _keyframes[i];
 
        if (cur->time() <= time)
        {
            *k1     = cur;
            kfIndex = i;
        }
    }
 
    // time is than first kf
    if (*k1 == nullptr)
    {
        *k1 = _keyframes.back();
        // as long as k1 is in the back
    }
 
    t1 = (*k1)->time();
 
    if (*k1 == _keyframes.back())
    {
        *k2 = _keyframes.front();
        t2  = animationLength + (*k2)->time();
    }
    else
    {
        *k2 = _keyframes[kfIndex + 1];
        t2  = (*k2)->time();
    }
 
    if (Utils::abs(t1 - t2) < 0.0001f)
        return 0.0f;
 
    /// @todo   do we want to consider the edge case below or do we want
    ///         imported animations to have to have a keyframe at 0.0 time?
    ///         Is there a better solution for this problem?
    ///         e.x: the astroboy animation looks wrong when doing this
    ///         (but thats because it is **** and kf0 and kfn dont match up...
    //
    // if an animation doesn't have a keyframe at 0.0 and
    // k1 is the last keyframe and k2 is the first keyframe
    // and the current timestamp is just above zero in the timeline
    //
    // like this:
    //   0.0                                animationLenth
    //    |-.--*----------*----*------*------|~~~~*
    //      ^  ^                      ^           ^
    //      |  t2                     t1          t2'
    //
    //     t2' is where we put the t2 value if its a wrap around!
    //     time
    // then the calculation below wont work because time < t1.
    //
    //
    if (time < t1)
        time += animationLength;
 
    return (time - t1) / (t2 - t1);
}

keyframe()

SLAnimKeyframe * SLAnimTrack::keyframe

(

SLint

index

)

Getter for keyframes by index.

Definition at line 48 of file SLAnimTrack.cpp.

{
    if (index < 0 || index >= numKeyframes())
        return nullptr;
 
    return _keyframes[(SLuint)index];
}

numKeyframes()

SLint SLAnimTrack::numKeyframes ( ) const

inline

Definition at line 47 of file SLAnimTrack.h.

{ return (SLint)_keyframes.size(); }

Member Data Documentation

_animation

SLAnimation* SLAnimTrack::_animation

protected

parent animation that created this track

Definition at line 54 of file SLAnimTrack.h.

_keyframes

SLVKeyframe SLAnimTrack::_keyframes

protected

keyframe list for this track

Definition at line 55 of file SLAnimTrack.h.

---

The documentation for this class was generated from the following files:

• SLAnimTrack.h
• SLAnimTrack.cpp