SO3SequenceAnimation.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Animation/SO3SequenceAnimation.h"
#include "SO3Animation/SO3SequenceAnimationTrack.h"
#include "SO3SceneGraph/SO3Skeleton.h"
 
namespace SO3
{
 
SSequenceAnimation::SSequenceAnimation(SScene* scene, const std::string& animationName, const unsigned short& id) : SAnim(scene, animationName, 0, id, SAnim::SO3_SEQUENCE_ANIM)
{
  ogreAnimation = mScene->GetOgreScenePointer()->createAnimation(animationName, 0.0f);
  ogreAnimationState = mScene->GetOgreScenePointer()->createAnimationState(animationName);
  mLastPos = 0.0f;
  mState = false;
}
SSequenceAnimation::SSequenceAnimation(SScene* scene, const std::string& animationName, const unsigned short& id) : SAnim(scene, animationName, 0, id, SAnim::SO3_SEQUENCE_ANIM) {…}
 
SSequenceAnimation::SSequenceAnimation() : SAnim(0, "", 0, 0, SO3_UNKNOWN_ANIM)
{
  // Forbiden (private)
}
 
SSequenceAnimation::~SSequenceAnimation()
{
  if (mScene->GetOgreScenePointer()->hasAnimationState(name))
    mScene->GetOgreScenePointer()->destroyAnimationState(name);
  ogreAnimationState = 0;
  if (mScene->GetOgreScenePointer()->hasAnimation(name))
    mScene->GetOgreScenePointer()->destroyAnimation(name);
}
SSequenceAnimation::~SSequenceAnimation() {…}
 
SAnimTrack* SSequenceAnimation::CreateAnimationTrackImpl(const std::string& newAnimationTrackName)
{
  return new SSequenceAnimationTrack(newAnimationTrackName, this, 0);
}
SAnimTrack* SSequenceAnimation::CreateAnimationTrackImpl(const std::string& newAnimationTrackName) {…}
 
Ogre::AnimationState* SSequenceAnimation::_GetOgreAnimationState()
{
  return ogreAnimationState;
}
Ogre::AnimationState* SSequenceAnimation::_GetOgreAnimationState() {…}
 
void SSequenceAnimation::SetTimePosition(const float& timePosition)
{
  if (_GetOgreAnimationState())
    _GetOgreAnimationState()->setTimePosition(timePosition);
 
  //update tracks
  if (GetEnable())
  {
    SAnimTrackList::iterator iAnimationTrack = animationTrackList.begin();
    while (iAnimationTrack != animationTrackList.end())
    {
      (*iAnimationTrack)->Update(timePosition);
      iAnimationTrack++;
    }
    //force update current animations
    //GetParentScene()->GetOgreScenePointer()->_applySceneAnimations();
  }
 
  mLastPos = timePosition;
}
void SSequenceAnimation::SetTimePosition(const float& timePosition) {…}
 
void SSequenceAnimation::SetEnable(const bool& enable)
{
  //if (ogreAnimationState)
        //  ogreAnimationState->setEnabled(enable);
  mState = enable;
 
  SetPaused(!enable);
  
  const SAnimTrackList animationTrackCopy = animationTrackList;
  SAnimTrackList::const_iterator iAnimationTrack = animationTrackCopy.begin();
  while (iAnimationTrack != animationTrackCopy.end())
  {
    static_cast<SSequenceAnimationTrack*>(*iAnimationTrack)->EnableTrackKeys(enable);
    iAnimationTrack++;
  }
}
void SSequenceAnimation::SetEnable(const bool& enable) {…}
 
bool SSequenceAnimation::GetEnable()
{
  return mState;
}
bool SSequenceAnimation::GetEnable() {…}
 
void SSequenceAnimation::UpdateAnimationLength()
{
  float length = 0.0f;
  const SAnimTrackList animationTrackCopy = animationTrackList;
  SAnimTrackList::const_iterator iAnimationTrack = animationTrackCopy.begin();
  while (iAnimationTrack != animationTrackCopy.end())
  {
    if (static_cast<SSequenceAnimationTrack*>(*iAnimationTrack)->GetLength() > length)
      length = static_cast<SSequenceAnimationTrack*>(*iAnimationTrack)->GetLength();
 
    iAnimationTrack++;
  }
  SetLength(length);
}
void SSequenceAnimation::UpdateAnimationLength() {…}
 
float SSequenceAnimation::GetLastPos()
{
  return mLastPos;
}
float SSequenceAnimation::GetLastPos() {…}
 
void SSequenceAnimation::_UpdateImpl(const Ogre::FrameEvent &evt)
{
  //$BB max time is set to 16 millisecond (one frame / 60)
  Ogre::Real maxtime = (evt.timeSinceLastFrame <= 0.016f) ? evt.timeSinceLastFrame : (evt.timeSinceLastFrame * 0.016f / evt.timeSinceLastFrame);
 
  if (SkipFrame())
    AddTime((float)evt.timeSinceLastFrame * GetSpeed());
  else
    AddTime(maxtime * GetSpeed());
 
  float currentPos = GetTimePosition();
 
  SAnimTrackList::iterator iAnimationTrack = animationTrackList.begin();
  while (iAnimationTrack != animationTrackList.end())
  {
    (*iAnimationTrack)->Update(GetTimePosition());
    iAnimationTrack++;
  }
 
  mLastPos = currentPos;
}
void SSequenceAnimation::_UpdateImpl(const Ogre::FrameEvent &evt) {…}
 
}