AnimationBlender - Ogre实现不同动画之间的混合

来源：互联网发布：java程序员的自我介绍编辑：程序博客网时间：2024/04/30 20:52

英文原文: http://test.ogitor.org/tiki/AnimationBlender

动画混合 -- 实现两个动画的切换, 一个动画逐渐消逝, 另一个动画逐渐显示来实现. 主要通过动画状态的权重来实现
通过三种方式来实现两个动画的混合:
   - BlendSwitch - 直接切换至目标动画
   - BlendWhileAnimating - 混合的过程中目标动画也更新帧, 实现动画
   - BlendThenAnimate - 用源动画的当前帧混合目标动画的第一个帧

源码理解, 主要代码位于下面两个函数
AnimationBlender::blend函数根据传入的参数设置新转换的源动画和目标动画
AnimationBlender::add函数则更新源动画和目标动画(如存在)的状态和权重

AnimationBlender::blend函数
1. 如果动画转换类型为 AnimationBlender::BlendSwitch
    直接将源动画转换成目标动画
2. 如果不是这个转换类型 AnimationBlender::BlendSwitch
    如果上次的动画转换还未完成
        如果新的目标动画等于上次转换的源动画
            则反向转换
        如果新的目标动画不等于上次转换的源动画和目标动画
            根据上次转换的剩余时间设置是显示上次转换的源动画还是目标动画, 并将其设置为新转换的源动画
            显示新转换的目标动画, 并设置其权重
    假设上次的动画转换已经完成了转换
        设置转换时间, 转换类型, 目标动画和其权重

AnimationBlender::addTime 函数
1. 如有动画在运行
    如果存在转换
        更新剩余时间
            如剩余时间小于0
                禁止源动画
                将目标动画设置为源动画, 继续运行
            如剩余时间不小于0
                更新源动画和目标动画的权重
                如转换类型为AnimationBlender::BlendWhileAnimating
                    更新目标动画
    判断动画是否完成
        更新源动画

完整代码和Demo代码

AnimationBlender.h

view sourceprint?
01#ifndef __ANIMATION_BLENDER_H__
02#define __ANIMATION_BLENDER_H__
03#include <Ogre.h>
04usingnamespaceOgre; 
05classAnimationBlender 
06{ 
07public:
08    enumBlendingTransition 
09    { 
10        BlendSwitch,        // stop source and start dest
11        BlendWhileAnimating,  // cross fade, blend source animation out while blending destination animation in
12        BlendThenAnimate     // blend source to first frame of dest, when done, start dest anim
13    }; 
14private:
15    Entity *mEntity;
16    AnimationState *mSource;
17    AnimationState *mTarget;
18    BlendingTransition mTransition;
19    boolloop; 
20    ~AnimationBlender() {}
21public: 
22    Real mTimeleft, mDuration;
23    boolcomplete; 
24    voidblend( constString &animation, BlendingTransition transition, Real duration,booll=true); 
25    voidaddTime( Real ); 
26    Real getProgress() {returnmTimeleft/ mDuration; } 
27    AnimationState *getSource() {returnmSource; } 
28    AnimationState *getTarget() {returnmTarget; } 
29    AnimationBlender( Entity *);
30    voidinit( constString &animation, booll=true); 
31}; 
32#endif

AnimationBlender.cpp

view sourceprint?
001#include "AnimationBlender.h"
002voidAnimationBlender::init(constString &animation, booll) 
003{ 
004    // 初始化, 将所有的动画禁止, 只允许参数中的动画运行.
005    AnimationStateSet *set = mEntity->getAllAnimationStates();
006    AnimationStateIterator it = set->getAnimationStateIterator();
007    while(it.hasMoreElements())
008    { 
009        AnimationState *anim = it.getNext();
010        anim->setEnabled(false);
011        anim->setWeight(0);
012        anim->setTimePosition(0);
013    } 
014    mSource = mEntity->getAnimationState( animation );
015    mSource->setEnabled(true);
016    mSource->setWeight(1);
017    mTimeleft = 0;
018    mDuration = 1;
019    mTarget = 0;
020    complete =false;
021    loop = l;
022}  
023voidAnimationBlender::blend( constString &animation, BlendingTransition transition, Real duration,booll ) 
024{ 
025    loop = l;
026    if( transition == AnimationBlender::BlendSwitch )
027    { 
028        if( mSource != 0 )
029            mSource->setEnabled(false);
030        mSource = mEntity->getAnimationState( animation );
031        mSource->setEnabled(true);
032        mSource->setWeight(1);
033        mSource->setTimePosition(0);
034        mTimeleft = 0;
035    }  
036    else 
037    {  
038        AnimationState *newTarget = mEntity->getAnimationState( animation );
039        if( mTimeleft > 0 )
040        {
041            // oops, weren't finished yet
042            if( newTarget == mTarget )
043            {
044                // nothing to do! (ignoring duration here)
045            }
046            elseif( newTarget == mSource )
047            {
048                // going back to the source state, so let's switch
049                mSource = mTarget;
050                mTarget = newTarget;
051                mTimeleft = mDuration - mTimeleft;// i'm ignoring the new duration here
052            }
053            else
054            {
055                // ok, newTarget is really new, so either we simply replace the target with this one, or
056                // we make the target the new source
057                if( mTimeleft < mDuration * 0.5 )
058                {
059                    // simply replace the target with this one
060                    mTarget->setEnabled(false);
061                    mTarget->setWeight(0);
062                }
063                else
064                {
065                    // old target becomes new source
066                    mSource->setEnabled(false);
067                    mSource->setWeight(0);
068                    mSource = mTarget;
069                } 
070                mTarget = newTarget;
071                mTarget->setEnabled(true);
072                mTarget->setWeight( 1.0 - mTimeleft / mDuration );
073                mTarget->setTimePosition(0);
074            }
075        }
076        else
077        {
078            // assert( target == 0, "target should be 0 when not blending" )
079            // mSource->setEnabled(true);
080            // mSource->setWeight(1);
081            mTransition = transition;
082            mTimeleft = mDuration = duration;
083            mTarget = newTarget;
084            mTarget->setEnabled(true);
085            mTarget->setWeight(0);
086            mTarget->setTimePosition(0);
087        }
088    } 
089} 
090voidAnimationBlender::addTime( Real time) 
091{ 
092    if( mSource != 0 )
093    { 
094        if( mTimeleft > 0 )
095        {
096            mTimeleft -=time;
097            if( mTimeleft < 0 )
098            {
099                // finish blending
100                mSource->setEnabled(false);
101                mSource->setWeight(0);
102                mSource = mTarget;
103                mSource->setEnabled(true);
104                mSource->setWeight(1);
105                mTarget = 0;
106            }
107            else
108            {
109                // still blending, advance weights
110                mSource->setWeight(mTimeleft / mDuration);
111                mTarget->setWeight(1.0 - mTimeleft / mDuration);
112                if(mTransition == AnimationBlender::BlendWhileAnimating)
113                    mTarget->addTime(time);
114            }
115        }
116        if(mSource->getTimePosition() >= mSource->getLength()) 
117        {
118            complete =true;
119        }
120        else
121        {
122            complete =false;
123        }
124        mSource->addTime(time);
125        mSource->setLoop(loop);
126    } 
127} 
128AnimationBlender::AnimationBlender( Entity *entity ) : mEntity(entity) 
129{ 
130}

AnimationBlenderDemo.h

view sourceprint?
01<P>#ifndef __ANIMATIONBLENDER_DEMO_H__
02#define __ANIMATIONBLENDER_DEMO_H__
03#include "ExampleApplication.h"
04#include "AnimationBlender.h"
05classAnimationBlenderDemoFrameListener : publicExampleFrameListener 
06{ 
07protected:
08    Entity* mNinjaEnt;
09    AnimationBlender* mAnimationBlender;
10    boolwalking, jumping; 
11public:
12    AnimationBlenderDemoFrameListener(RenderWindow* mWin, Camera* mCam, Entity* ent)
13        : ExampleFrameListener(mWin, mCam,false,false), mNinjaEnt(ent)
14    { 
15        mAnimationBlender =newAnimationBlender(mNinjaEnt); 
16        mAnimationBlender->init("Walk",true);
17        walking =false;
18        jumping =false;
19    } 
20    virtual~AnimationBlenderDemoFrameListener() 
21    { 
22        if(mAnimationBlender)
23        {
24//          delete mAnimationBlender;
25        }
26    } 
27    boolframeRenderingQueued(constFrameEvent& evt) 
28    { 
29        if(!ExampleFrameListener::frameRenderingQueued(evt)) 
30        {
31            returnfalse;
32        }
33        if(!walking) 
34        {
35            mAnimationBlender->blend("Walk",AnimationBlender::BlendWhileAnimating, 0.2,true); 
36            walking=true;
37        }
38        if(mKeyboard->isKeyDown( OIS::KC_SPACE ) && !jumping) 
39        {
40            jumping=true;
41            mAnimationBlender->blend("Jump",AnimationBlender::BlendWhileAnimating, 0.2,false); 
42        }
43        if(jumping) 
44        {
45            if(mAnimationBlender->complete) 
46            {
47                mAnimationBlender->blend("Idle1",AnimationBlender::BlendWhileAnimating, 0.02,true); 
48                jumping=false;
49            }
50        }
51        mAnimationBlender->addTime(evt.timeSinceLastFrame);
52        returntrue;
53    } 
54}; 
55classAnimationBlenderDemoApp : publicExampleApplication 
56{ 
57public:
58    AnimationBlenderDemoApp() {}
59protected:
60    Entity* mNinjaEnt;
61    voidcreateScene(); 
62    voidcreateFrameListener() 
63    { 
64        mFrameListener =newAnimationBlenderDemoFrameListener(mWindow, mCamera, mNinjaEnt);
65        mRoot->addFrameListener(mFrameListener);
66    } 
67}; 
68#endif</P>

AnimationBlenderDemo.cpp

view sourceprint?
01<P>#include "AnimationBlenderDemo.h"
02#include <OgreStringConverter.h>
03voidAnimationBlenderDemoApp::createScene() 
04{ 
05mSceneMgr->setAmbientLight(ColourValue(1.0, 1.0, 1.0));
06mNinjaEnt = mSceneMgr->createEntity("Ninja","ninja.mesh");
07SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
08node->attachObject(mNinjaEnt); 
09} 
10#ifdef __cplusplus
11extern"C" { 
12#endif
13#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
14#define WIN32_LEAN_AND_MEAN
15#include "windows.h"
16INTWINAPI WinMain( HINSTANCEhInst, HINSTANCE,LPSTRstrCmdLine, INT) 
17#else
18intmain(intargc, char**argv) 
19#endif
20{ 
21AnimationBlenderDemoApp app; 
22try{ 
23    app.go();
24} catch( Ogre::Exception& e ) {
25#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
26    MessageBox( NULL, e.getFullDescription().c_str(),"An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL );
27#else
28    std::cerr <<"An exception has occured: "<< e.getFullDescription(); 
29#endif
30} 
31return0; 
32} 
33#ifdef __cplusplus
34} 
35#endif</P>

不过由于Ninja.mesh的动画时间太小, 很难看出混合效果, 以上代码适合Ogre1.6.5