Ogre播放动画

class TutorialApplication : public BaseApplication
{
public:
    TutorialApplication(void);
    virtual ~TutorialApplication(void);

protected:
    virtual void createScene(void);
	virtual bool frameRenderingQueued(const Ogre::FrameEvent& evt);
private:
	bool nextLocation();

	std::deque<Ogre::Vector3> mWalkList;
	Ogre::Real mDistance;
	Ogre::Real mWalkSpd;
	Ogre::Vector3 mDirection;
	Ogre::Vector3 mDestination;
	Ogre::AnimationState* mAnimationState;
	Ogre::Entity* mEntity;
	Ogre::SceneNode* mNode;

};

//---------------------------------------------------------------------------
TutorialApplication::TutorialApplication(void):
	mDistance(0),
	mWalkSpd(70.0),
	mDirection(Ogre::Vector3::ZERO),
	mDestination(Ogre::Vector3::ZERO),
	mAnimationState(0),
	mEntity(0),
	mNode(0)
{
}
//---------------------------------------------------------------------------
TutorialApplication::~TutorialApplication(void)
{
}

//---------------------------------------------------------------------------
void TutorialApplication::createScene(void)
{
    // Create your scene here :)

	mSceneMgr->setAmbientLight(Ogre::ColourValue(1.0,1.0,1.0));
	mEntity = mSceneMgr->createEntity("robot.mesh");

	mNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(Ogre::Vector3(0,0,25.0));
	mNode->attachObject(mEntity);

	mWalkList.push_back(Ogre::Vector3(550.0, 0, 50.0));
	mWalkList.push_back(Ogre::Vector3(-100.0, 0, -200.0));
	mWalkList.push_back(Ogre::Vector3(0, 0, 25.0));

	Ogre::Entity* ent;
	Ogre::SceneNode* node;

	ent = mSceneMgr->createEntity("knot.mesh");
	node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		Ogre::Vector3(0, -10.0, 25.0));
	node->attachObject(ent);
	node->setScale(0.1, 0.1, 0.1);

	ent = mSceneMgr->createEntity("knot.mesh");
	node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		Ogre::Vector3(550.0, -10.0, 50.0));
	node->attachObject(ent);
	node->setScale(0.1, 0.1, 0.1);

	ent = mSceneMgr->createEntity("knot.mesh");
	node = mSceneMgr->getRootSceneNode()->createChildSceneNode(
		Ogre::Vector3(-100.0, -10.0,-200.0));
	node->attachObject(ent);
	node->setScale(0.1, 0.1, 0.1);

	mCamera->setPosition(90.0, 280.0, 535.0);
	mCamera->pitch(Ogre::Degree(-30.0));
	mCamera->yaw(Ogre::Degree(-15.0));

	mAnimationState = mEntity->getAnimationState("Idle");
	mAnimationState->setLoop(true);
	mAnimationState->setEnabled(true);


}

bool TutorialApplication::frameRenderingQueued(const Ogre::FrameEvent& evt)
{
	if (mDirection == Ogre::Vector3::ZERO)
	{
		if (nextLocation())
		{
			mAnimationState = mEntity->getAnimationState("Walk");
			mAnimationState->setLoop(true);
			mAnimationState->setEnabled(true);
		}
	}
	else
	{
		Ogre::Real move = mWalkSpd * evt.timeSinceLastFrame;
		mDistance -= move;

		if (mDistance <= 0.0)
		{
			mNode->setPosition(mDestination);
			mDirection = Ogre::Vector3::ZERO;

			if (nextLocation())
			{
				Ogre::Vector3 src = mNode->getOrientation() * Ogre::Vector3::UNIT_X;

				if ((1.0 + src.dotProduct(mDirection)) < 0.0001)
				{
					mNode->yaw(Ogre::Degree(180));
				}
				else
				{
					Ogre::Quaternion quat = src.getRotationTo(mDirection);
					mNode->rotate(quat);
				}
			}
			else
			{
				mAnimationState = mEntity->getAnimationState("Idle");
				mAnimationState->setLoop(true);
				mAnimationState->setEnabled(true);
			}
		}
		else
		{
			mNode->translate(move * mDirection);
		}
	}

	mAnimationState->addTime(evt.timeSinceLastFrame);

	return BaseApplication::frameRenderingQueued(evt);
}

bool TutorialApplication::nextLocation()
{
	if (mWalkList.empty())
		return false;

	mDestination = mWalkList.front();
	mWalkList.pop_front();
	mDirection = mDestination - mNode->getPosition();
	mDistance = mDirection.normalise();

	return true;
}