一、基本框架

先看一下OGRE动画的基本框架:

http://blog.csdn.net/leonwei/article/details/5819248

 

二、动画控制

OGRE的基本动画控制是很简单的,设置一个动画的操作是这样:

 

// Set idle animation

mAnimationState = ent->getAnimationState( "Idle" );

mAnimationState->setLoop( true );

mAnimationState->setEnabled( true );

(上面这段代码来自Intermediate Tutorial1 – Ogre Wiki)从一个Entity对象中得到AnimationState指针,然后设置一些属性,在每帧需要调用(FrameListener中):

mAnimationState->addTime( evt.timeSinceLastFrame );

传入每帧的时间,这样动画就开始动起来了。

 

三、动画资源加载

1.Skeleton加载

可以通过SkeletonManager来加载骨骼文件。

SkeletonPtr skel = SkeletonManager::getSingleton().load("jaiqua.skeleton", 

ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

这个load是SkeletonManager所继承的ResourceManager的虚函数load。

 ResourcePtr ResourceManager::load(const String& name, 
const String& group, bool isManual, ManualResourceLoader* loader,
const NameValuePairList* loadParams)
{
ResourcePtr r = createOrRetrieve(name,group,isManual,loader,loadParams).first;
// ensure loaded
r->load();
return r;
}

里边创建一个Resource,这边就是Skeleton了,并调用他的load函数。

这个load函数也是继承来的,它是继承于Resource类的,Ogre里的资源都是继承这个类的,如Material,Mesh等。

 void Resource::load(bool background)
{
...
    if (old==LOADSTATE_UNLOADED)
prepareImpl();

preLoadImpl();

old = LOADSTATE_PREPARED;

if (mGroup == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
{
// Derive resource group
changeGroupOwnership(
ResourceGroupManager::getSingleton()
.findGroupContainingResource(mName));
}

loadImpl();

postLoadImpl();
...
}

这里边的主要加载资源逻辑就是在loadImpl(),这是个纯虚函数,具体由子类来实现,我们现在读取的是skeleton,因此就是使用skeleton类中的loadImpl().

void Skeleton::loadImpl(void)
{
SkeletonSerializer serializer;
LogManager::getSingleton().stream()
<< "Skeleton: Loading " << mName;

DataStreamPtr stream =
ResourceGroupManager::getSingleton().openResource(
mName, mGroup, true, this);

serializer.importSkeleton(stream, this);

// Load any linked skeletons
LinkedSkeletonAnimSourceList::iterator i;
for (i = mLinkedSkeletonAnimSourceList.begin();
i != mLinkedSkeletonAnimSourceList.end(); ++i)
{
i->pSkeleton = SkeletonManager::getSingleton().load(
i->skeletonName, mGroup);
}


}

此函数主要进行了两件事:1、用SkeletonSerializer来解析文件数据流,保存到当前的skeleton实例中;2、载入所有相关连的skeleton(在.skeleton文件的<animationlinks>标签中定义)。

动画信息存储在Skeleton的“AnimationList mAnimationsList”成员变量中,可以根据动画的名字来获取相应的动画信息

SkeletonPtr skel = SkeletonManager::getSingleton().load("Jaiqua.skeleton",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

Animation* anim = skel->getAnimation("Sneak");


这边说一下Skeleton和SkeletonInstance的区别,SkeletonInstance继承了Skeleton,内部保存了一个指向Skeleton的指针。可以打开SkeletonInstance的头文件,可以看到一段简短的英文描述。

/** A SkeletonInstance is a single instance of a Skeleton used by a world object.
@remarks
The difference between a Skeleton and a SkeletonInstance is that the
Skeleton is the 'master' version much like Mesh is a 'master' version of
Entity. Many SkeletonInstance objects can be based on a single Skeleton,
and are copies of it when created. Any changes made to this are not
reflected in the master copy. The exception is animations; these are
shared on the Skeleton itself and may not be modified here.
*/

 

简单翻译如下:

一个SkeletonInstance类是一个单一的Skeleton的一个实例,Skeleton是一个宿主,就像一个Mesh可以有多个Entity一样。一个Skeleton可以有许多个SkeletonInstance,每个SkeletonInstance拷贝了一份Skeleton信息,对SkeletonInstance里的一些信息的更改不会影响到Skeleton里的信息,但是对动画的修改就会影响到Skeleton里的动画,因为动画信息是共享的。

这边最典型的好处就是可以动态的为骨骼添加一些东西,如武器,装备等。

 

2.Mesh加载
skeleton单独加载进来了,那Mesh怎么知道哪个skeleton是他的呢?如果用XML转换器将.mesh文件转为XML,打开可以看到在文件末尾有 <skeletonlink name="jaiqua.skeleton" />

所以他会在加载Mesh的时候加载进来。

现在来看Mesh的加载步骤。。这个加载真是能把人绕晕掉。。

先从调用的地方开始看:

Entity* ent = mSceneMgr->createEntity("jaiQua", "jaiqua.mesh");

跳转到:

Entity* SceneManager::createEntity(
const String& entityName,
const String& meshName )
{
// delegate to factory implementation
NameValuePairList params;
params["mesh"] = meshName;
return static_cast<Entity*>(
createMovableObject(entityName, EntityFactory::FACTORY_TYPE_NAME,
&params));

}

代理给工产方法:

MovableObject* SceneManager::createMovableObject(const String& name, 
const String& typeName, const NameValuePairList* params)
{
...
MovableObjectFactory* factory =
Root::getSingleton().getMovableObjectFactory(typeName);

MovableObject* newObj = factory->createInstance(name, this, params);
...
}


调用工厂方法:

MovableObject* MovableObjectFactory::createInstance(
const String& name, SceneManager* manager,
const NameValuePairList* params)
{
MovableObject* m = createInstanceImpl(name, params);
m->_notifyCreator(this);
m->_notifyManager(manager);
return m;
}
createInstanceImpl()是一个纯虚函数,由不同的子类各自实现,这边就是调用Entity的方法了。
MovableObject* EntityFactory::createInstanceImpl( const String& name,
const NameValuePairList* params)
{
// must have mesh parameter
MeshPtr pMesh;
if (params != 0)
{
NameValuePairList::const_iterator ni = params->find("mesh");
if (ni != params->end())
{
// Get mesh (load if required)
pMesh = MeshManager::getSingleton().load(
ni->second,
// autodetect group location
ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
}

}
if (pMesh.isNull())
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"'mesh' parameter required when constructing an Entity.",
"EntityFactory::createInstance");
}

return OGRE_NEW Entity(name, pMesh);

}
这边也开始调用load函数了,这才开始进入mesh资源的加载。
加载的过程跟skeleton类似,因此只挑重点的说一下:
经过若干次跳转后。。调用到MeshSerializerImpl::importMesh
void MeshSerializerImpl::importMesh(DataStreamPtr& stream, Mesh* pMesh, MeshSerializerListener *listener)
{
// Determine endianness (must be the first thing we do!)
determineEndianness(stream);

// Check header
readFileHeader(stream);

unsigned short streamID;
while(!stream->eof())
{
streamID = readChunk(stream);
switch (streamID)
{
case M_MESH:
readMesh(stream, pMesh, listener);
break;
}

}
}
跟踪下去:
MeshSerializerImpl::readMesh()――case M_MESH_SKELETON_LINK:

=》MeshSerializerImpl::readSkeletonLink();
=》Mesh::setSkeletonName();
=》mSkeleton = SkeletonManager::getSingleton().load(skelName, mGroup);――得到骨骼指针

mSkeleton为Mesh里保存的骨骼的指针。
这样就从Entity中可以得到对应的骨骼了。
SkeletonInstance* skelIns = ent->getSkeleton();

3.动画集合

Animation类的对象就是“An animation sequence”,各种类型的动画序列都由这个类来管理。它管理了三种类型的Track list,分别是:NodeAnimationTrack、NumericAnimationTrack、VertexAnimationTrack。

通俗的讲就是一个动画是由它的各个部分的动画轨迹组成的。比如人的动画是由他的头和四肢的轨迹组成的。

AnimationState是一个Animation的状态管理类,可以在里边设置动画的权重,设置动画是否开启,是否循环等状态。

AnimationStateSet就是所有的AnimationState的集合。


在Entity的构造函数中,如果Mesh含有骨骼动画或者顶点动画,则会new一个AnimationStateSet对象,并调用“mesh->_initAnimationState(mAnimationState);”。

void Entity::_initialise(bool forceReinitialise)
{
...
// Is mesh skeletally animated?
if (mMesh->hasSkeleton() && !mMesh->getSkeleton().isNull())
{
mSkeletonInstance = OGRE_NEW SkeletonInstance(mMesh->getSkeleton());
mSkeletonInstance->load();
}

// Initialise the AnimationState, if Mesh has animation
if (hasSkeleton())
{
mFrameBonesLastUpdated = OGRE_NEW_T(unsigned long, MEMCATEGORY_ANIMATION)(std::numeric_limits<unsigned long>::max());
mNumBoneMatrices = mSkeletonInstance->getNumBones();
mBoneMatrices = static_cast<Matrix4*>(OGRE_MALLOC_SIMD(sizeof(Matrix4) * mNumBoneMatrices, MEMCATEGORY_ANIMATION));
}
if (hasSkeleton() || hasVertexAnimation())
{
mAnimationState = OGRE_NEW AnimationStateSet();
mMesh->_initAnimationState(mAnimationState);
prepareTempBlendBuffers();
}
...
}
可以看到Entity中用的是SkeletonInstance,而不是直接用mesh的Skeleton。

4.动画的更新

主要运算就在“void Entity::updateAnimation(void)”函数中。

=》 Entity::cacheBoneMatrices
=》 Skeleton::setAnimationState
此函数先是调用“Skeleton::reset”,然后针对每个enabled animation state,找到其对应的Animation,然后调用Animation::apply()来计算每个Bone的状态。



几个小技巧:

1.复制动画

Animation* copyAnim = skel->createAnimation("OldSneak", anim->getLength());
*copyAnim = *(anim->clone("OldSneak"));
ent->refreshAvailableAnimationState();

记得要refresh才能用,不然找不到。

2.添加动画:

SkeletonInstance* skelIns = ent->getSkeleton();
skelIns->addLinkedSkeletonAnimationSource("XX.skeleton");