SO3Anim.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/SO3Anim.h"
#include "SO3Animation/SO3AnimTrack.h"
#include "SO3Animation/SO3SequenceAnimationTrack.h"
#include "SO3SceneGraph/SO3NodeScol.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Skeleton.h"
 
namespace SO3
{
 
SAnim::SAnim(SScene* scene, const std::string& animationName, SNode* animationAssociatedNode, const unsigned short& animationId, const AnimType& animationType) : SData(animationName), type(animationType)
{
        ogreAnimation = 0;
  bUpdatedBySequence = 0;
 
  mScene = scene;
        associatedNode = animationAssociatedNode;
  animationIndex = animationId;
        mSpeed = 1.0f;
  mWeight = 0.0f;
  isPaused = true;
  skipFrame = true;
  ogreAnimationFrameListener = new SAnimationFrameListener(this);
  Ogre::Root::getSingleton().addFrameListener(ogreAnimationFrameListener);
}
 
SAnim::SAnim() : SData(""), type(SO3_UNKNOWN_ANIM)
{
  // Forbiden (private)
}
 
SAnim::~SAnim()
{
  Ogre::Root::getSingleton().removeFrameListener(ogreAnimationFrameListener);
  delete(ogreAnimationFrameListener);
  ogreAnimationFrameListener = 0;
 
  //remove sequence animation keys containing this animation
  const SAnimMap seqAnimCopy = mScene->GetAnimations();
  SAnimMap::const_iterator iSeqAnim = seqAnimCopy.begin();
  while(iSeqAnim != seqAnimCopy.end())
  {
    SAnim* seqanim = iSeqAnim->second;
  
    //Do not treat the actual animation
    if ((seqanim != this) && (seqanim->GetType() == SAnim::SO3_SEQUENCE_ANIM))
    {
      const SAnimTrackList SeqTrackCopy = seqanim->GetAnimationsTracks();
      SAnimTrackList::const_iterator iSeqTrack = SeqTrackCopy.begin();
      while(iSeqTrack != SeqTrackCopy.end())
      {
        try
        {
          SSequenceAnimationTrack* seqtrack = static_cast<SSequenceAnimationTrack*>(*iSeqTrack);
          seqtrack->RemoveKeysWithAnim(this, false);
        }
        catch(Ogre::Exception)
        {
        }
        iSeqTrack++;
      }
    }
 
    iSeqAnim++;
  }
 
  SAnimTrackList animationTrackListCopy = animationTrackList;
  SAnimTrackList::iterator iAnimTrack = animationTrackListCopy.begin();
  while(iAnimTrack != animationTrackListCopy.end())
  {
    RemoveAnimationTrack(*iAnimTrack);
    SO3_SAFE_DELETE(*iAnimTrack);
    iAnimTrack++;
  }
 
        associatedNode = 0;
  ogreAnimation = 0;
}
 
SScene* SAnim::GetParentScene()
{
  return mScene;
}
 
Ogre::Animation* SAnim::GetOgreAnimationPointer() 
{
        return ogreAnimation;
}
 
SNode* SAnim::GetParentNode()
{
        return associatedNode;
}
 
SAnim::AnimType SAnim::GetType()
{
  return type;
}
 
unsigned short SAnim::GetIndex()
{
  return animationIndex;
}
 
bool SAnim::SkipFrame()
{
  return skipFrame;
}
 
void SAnim::SetSkipFrame(const bool& state)
{
  skipFrame = state;
}
 
SAnimTrack* SAnim::CreateAnimationTrack(const std::string& newAnimationTrackName)
{
  SAnimTrack* newAnimationTrack = this->CreateAnimationTrackImpl(newAnimationTrackName);
 
  /* Check if our anim track was really created. If not, it's certainly that the SAnim derived class do not 
     re-implement CreateAnimationTrackImpl function, and it's SAnim::CreateAnimationTrackImpl that was called. */
  if(newAnimationTrack == 0)
    OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Can not create animation track named \""+ newAnimationTrackName +"\", this animation type may not handle user creation!", "SAnim::CreateAnimationTrack");
 
  AddAnimationTrack(newAnimationTrack);
  return newAnimationTrack;
}
 
SAnimTrack* SAnim::CreateAnimationTrackImpl(const std::string& newAnimationTrackName)
{
  return 0;
}
 
void SAnim::DeleteAnimationTrack(SAnimTrack* existingAnimationTrack)
{
  RemoveAnimationTrack(existingAnimationTrack);
  SO3_SAFE_DELETE(existingAnimationTrack);
}
 
unsigned short SAnim::GetNumAnimationsTracks()
{
  return animationTrackList.size();
}
 
SAnimTrack* SAnim::GetAnimationTrack(const unsigned short& index)
{
  if (((int)(animationTrackList.size()) - 1) < (int)index)
    return 0;
 
  return animationTrackList.at(index);
}
 
SAnimTrackList SAnim::GetAnimationsTracks() const
{
  return animationTrackList;
}
 
void SAnim::AddAnimationTrack(SAnimTrack* existingAnimationTrack)
{
  animationTrackList.push_back(existingAnimationTrack);
}
 
void SAnim::RemoveAnimationTrack(SAnimTrack* existingAnimationTrack)
{
  SAnimTrackList::iterator it = std::find(animationTrackList.begin(), animationTrackList.end(), existingAnimationTrack);
  if (it != animationTrackList.end())
    animationTrackList.erase(it);
}
 
void SAnim::SetLength(const float& length)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setLength(length);
}
 
float SAnim::GetLength()
{
  float length = 0.0f;
  if(_GetOgreAnimationState())
    length = _GetOgreAnimationState()->getLength();
 
  return length;
}
 
void SAnim::SetTimePosition(const float& timePosition)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setTimePosition(timePosition);
}
 
void SAnim::Apply(const float& timePosition)
{
  SetTimePosition(timePosition);
  
  //force update current animations
  GetParentScene()->GetOgreScenePointer()->_applySceneAnimations();
}
 
float SAnim::GetTimePosition()
{
  float pos = 0.0f;
  if(_GetOgreAnimationState())
    pos = _GetOgreAnimationState()->getTimePosition();
 
  return pos;
}
 
void SAnim::SetWeight(const float& weight)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setWeight(weight);
}
 
float SAnim::GetWeight()
{
  float weight = 0.0f;
  if(_GetOgreAnimationState())
    weight = _GetOgreAnimationState()->getWeight();
 
  return weight;
}
 
void SAnim::SetInitialWeight(const float& weight)
{
  SetWeight(weight);
  mWeight = weight;
}
 
float SAnim::GetInitialWeight()
{
  return mWeight;
}
 
void SAnim::SetInitialLoop(const bool& loop)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setLoop(loop);
  mLoop = loop;
}
 
bool SAnim::GetInitialLoop()
{
  return mLoop;
}
 
void SAnim::SetInterpolationMode(const SAnim::AnimInterpolationMode& interpolationMode)
{
  ogreAnimation->setInterpolationMode(static_cast <Ogre::Animation::InterpolationMode> (static_cast<int> (interpolationMode)));
}
 
SAnim::AnimInterpolationMode SAnim::GetInterpolationMode()
{
  return static_cast <AnimInterpolationMode> (ogreAnimation->getInterpolationMode());
}
 
void SAnim::SetRotationInterpolationMode(const SAnim::AnimRotationInterpolationMode& interpolationMode)
{
  ogreAnimation->setRotationInterpolationMode(static_cast <Ogre::Animation::RotationInterpolationMode> (static_cast<int> (interpolationMode)));
}
 
SAnim::AnimRotationInterpolationMode SAnim::GetRotationInterpolationMode()
{
  return static_cast <AnimRotationInterpolationMode> (ogreAnimation->getRotationInterpolationMode());
}
 
void SAnim::SetEnable(const bool& enable)
{
  if(_GetOgreAnimationState())
          _GetOgreAnimationState()->setEnabled(enable);
  SetPaused(!enable);
}
 
bool SAnim::GetEnable()
{
  bool ret = false;
  if(_GetOgreAnimationState())
    ret = _GetOgreAnimationState()->getEnabled();
 
  return ret;
}
 
void SAnim::SetLoop(const bool& loop)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setLoop(loop);
}
 
bool SAnim::GetLoop()
{
  bool ret = false;
  if(_GetOgreAnimationState())
    ret = _GetOgreAnimationState()->getLoop();
 
  return ret;
}
 
void SAnim::SetOptimise(const bool& optimize)
{
  if (ogreAnimation)
    ogreAnimation->optimise(optimize); 
}
 
void SAnim::SetSpeed(const float& newSpeed)
{
  mSpeed = newSpeed;
}
 
float SAnim::GetSpeed()
{
  return mSpeed;
}
 
bool SAnim::HasEnded()
{
  bool ret = true;
  if(_GetOgreAnimationState())
    ret = _GetOgreAnimationState()->hasEnded();
 
  return ret;
}
 
void SAnim::AddTime(const float& time)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->addTime(time);
}
 
void SAnim::SetPaused(const bool& pauseState)
{
  isPaused = pauseState;
}
 
bool SAnim::GetPaused()
{
  return isPaused;
}
 
void SAnim::Update(const Ogre::FrameEvent& evt)
{
  if(!IsSequenceUpdated() && GetEnable() && !isPaused)
    _UpdateImpl(evt);
}
 
SAnimationFrameListener::SAnimationFrameListener(SAnim* animationListened) : FrameListener()
{
  animation = animationListened;
}
 
SAnimationFrameListener::~SAnimationFrameListener(void)
{
  animation = 0;
}
 
void SAnim::_UpdateImpl(const Ogre::FrameEvent &evt)
{
  //$BB max time is set to 16 millisecond (one frame / 60)
  if (SkipFrame())
    AddTime((float)evt.timeSinceLastFrame * GetSpeed());
  else
    AddTime(std::min((float)evt.timeSinceLastFrame, 0.016f) * GetSpeed());
}
 
bool SAnim::IsSequenceUpdated()
{
  return (bUpdatedBySequence > 0);
}
 
void SAnim::SetSequenceUpdated(const bool& value)
{
  if (value)
    bUpdatedBySequence ++;
  else
    bUpdatedBySequence --;
}
 
bool SAnimationFrameListener::frameStarted(const Ogre::FrameEvent &evt)
{
  return true;
}
 
}