SO3Engine/SO3Animation/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "../SO3Animation/SO3SequenceAnimation.h"
#include "../SO3Animation/SO3SequenceAnimationTrack.h"
#include "../SO3SceneGraph/SO3Skeleton.h"

namespace SO3
{

SSequenceAnimation::SSequenceAnimation(SScene* scene, std::string animationName, 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;
}

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);
}

SAnimTrack* SSequenceAnimation::CreateAnimationTrackImpl(std::string newAnimationTrackName)
{
  return new SSequenceAnimationTrack(newAnimationTrackName, this, 0);
}

Ogre::AnimationState* SSequenceAnimation::_GetOgreAnimationState()
{
  return ogreAnimationState;
}

void SSequenceAnimation::SetTimePosition(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::SetEnable(bool enable)
{
  if (ogreAnimationState)
          ogreAnimationState->setEnabled(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::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);
}


float SSequenceAnimation::GetLastPos()
{
  return mLastPos;
}


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

}

---