SO3Engine/SO3Animation/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) 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 "SO3Anim.h"
#include "SO3AnimTrack.h"
#include "SO3SequenceAnimationTrack.h"
#include "../SO3SceneGraph/SO3NodeScol.h"
#include "../SO3SceneGraph/SO3Scene.h"
#include "../SO3SceneGraph/SO3Skeleton.h"
#include "../SCOLPack/SO3SCOL.h"

namespace SO3
{

SAnim::SAnim(SScene* scene, std::string animationName, SNode* animationAssociatedNode, unsigned short animationId, 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);
    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(bool state)
{
  skipFrame = state;
}

SAnimTrack* SAnim::CreateAnimationTrack(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(std::string newAnimationTrackName)
{
  return 0;
}

void SAnim::DeleteAnimationTrack(SAnimTrack* existingAnimationTrack)
{
  RemoveAnimationTrack(existingAnimationTrack);
  SAFE_DELETE(existingAnimationTrack);
}

unsigned short SAnim::GetNumAnimationsTracks()
{
  return animationTrackList.size();
}

SAnimTrack* SAnim::GetAnimationTrack(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(float length)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setLength(length);
}

float SAnim::GetLength()
{
  float length = 0.0f;
  if(_GetOgreAnimationState())
    length = _GetOgreAnimationState()->getLength();

  return length;
}

void SAnim::SetTimePosition(float timePosition)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setTimePosition(timePosition);
}

void SAnim::Apply(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(float weight)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setWeight(weight);
}

float SAnim::GetWeight()
{
  float weight = 0.0f;
  if(_GetOgreAnimationState())
    weight = _GetOgreAnimationState()->getWeight();

  return weight;
}

void SAnim::SetInitialWeight(float weight)
{
  SetWeight(weight);
  mWeight = weight;
}

float SAnim::GetInitialWeight()
{
  return mWeight;
}

void SAnim::SetInitialLoop(bool loop)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setLoop(loop);
  mLoop = loop;
}

bool SAnim::GetInitialLoop()
{
  return mLoop;
}

void SAnim::SetInterpolationMode(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(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(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(bool loop)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->setLoop(loop);
}

bool SAnim::GetLoop()
{
  bool ret = false;
  if(_GetOgreAnimationState())
    ret = _GetOgreAnimationState()->getLoop();

  return ret;
}

void SAnim::SetOptimise(bool optimize)
{
  if (ogreAnimation)
    ogreAnimation->optimise(optimize); 
}

void SAnim::SetSpeed(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(float time)
{
  if(_GetOgreAnimationState())
    _GetOgreAnimationState()->addTime(time);
}

void SAnim::SetPaused(bool pauseState)
{
  isPaused = pauseState;
}

bool SAnim::GetPaused()
{
  return isPaused;
}

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

bool SAnim::IsSequenceUpdated()
{
  return (bUpdatedBySequence > 0);
}

void SAnim::SetSequenceUpdated(bool value)
{
  if (value)
    bUpdatedBySequence ++;
  else
    bUpdatedBySequence --;
}

bool SAnimationFrameListener::frameStarted(const Ogre::FrameEvent &evt)
{
  if(animation && !animation->IsSequenceUpdated() && animation->GetEnable() && !animation->GetPaused())
    animation->_UpdateImpl(evt);

  return true;
}

}

---