基于OGRE实现一个简单的3D游戏（软件工程作业2）

基于OGRE实现一个简单的3D游戏（软件工程作业2）

学号：2011211910   

同组博客链接:http://thefrp.sinaapp.com/

题目：

实现一个3D游戏

最终效果：

游戏截图：

兽人和机器人敌人

游戏说明：

用WASD控制兽人前左右后移动，空格跳跃，Q拿起武器，鼠标左键和右键为攻击。没击杀一个机器人敌人，就会出现新的机器人敌人，无限模式。

学习体会：

  • 了解了基本的OGRE知识
  • 熟悉了C++编程
  • 结对编程的乐趣还有队友之间的协助，事半功倍
  • 第一次学习了有关游戏编程的东西，有一种创造的成就感

代码：

CharacterSample.h

  1. #ifndef __Character_H__
  2. #define __Character_H__
  4. #include"SdkSample.h"
  5. #include"SinbadCharacterController.h"
  7. usingnamespaceOgre;
  8. usingnamespaceOgreBites;
  10. class_OgreSampleClassExportSample_Character:publicSdkSample
  11. {
  12. public:
  14. Sample_Character()
  15. {
  16. mInfo["Title"]="Character";
  17. mInfo["Description"]="A demo showing 3rd-person character control and use of TagPoints.";
  18. mInfo["Thumbnail"]="thumb_char.png";
  19. mInfo["Category"]="Animation";
  20. mInfo["Help"]="Use the WASD keys to move Sinbad, and the space bar to jump. "
  21. "Use mouse to look around and mouse wheel to zoom. Press Q to take out or put back "
  22. "Sinbad's swords. With the swords equipped, you can left click to slice vertically or "
  23. "right click to slice horizontally. When the swords are not equipped, press E to "
  24. "start/stop a silly dance routine.";
  25. }
  27. bool frameRenderingQueued(constFrameEvent& evt)
  28. {
  29. // let character update animations and camera
  30. mChara->addTime(evt.timeSinceLastFrame);
  31. returnSdkSample::frameRenderingQueued(evt);
  32. }
  34. bool keyPressed(const OIS::KeyEvent& evt)
  35. {
  36. // relay input events to character controller
  37. if(!mTrayMgr->isDialogVisible()) mChara->injectKeyDown(evt);
  38. returnSdkSample::keyPressed(evt);
  39. }
  41. bool keyReleased(const OIS::KeyEvent& evt)
  42. {
  43. // relay input events to character controller
  44. if(!mTrayMgr->isDialogVisible()) mChara->injectKeyUp(evt);
  45. returnSdkSample::keyReleased(evt);
  46. }
  48. #if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
  49. bool touchPressed(const OIS::MultiTouchEvent& evt)
  50. {
  51. // relay input events to character controller
  52. if(!mTrayMgr->isDialogVisible()) mChara->injectMouseDown(evt);
  53. returnSdkSample::touchPressed(evt);
  54. }
  56. bool touchMoved(const OIS::MultiTouchEvent& evt)
  57. {
  58. // relay input events to character controller
  59. if(!mTrayMgr->isDialogVisible()) mChara->injectMouseMove(evt);
  60. returnSdkSample::touchMoved(evt);
  61. }
  62. #else
  63. bool mouseMoved(const OIS::MouseEvent& evt)
  64. {
  65. // relay input events to character controller
  66. if(!mTrayMgr->isDialogVisible()) mChara->injectMouseMove(evt);
  67. returnSdkSample::mouseMoved(evt);
  68. }
  70. bool mousePressed(const OIS::MouseEvent& evt, OIS::MouseButtonID id)
  71. {
  72. // relay input events to character controller
  73. if(!mTrayMgr->isDialogVisible()) mChara->injectMouseDown(evt, id);
  74. returnSdkSample::mousePressed(evt, id);
  75. }
  76. #endif
  78. protected:
  80. void setupContent()
  81. {
  82. // set background and some fog
  83. mViewport->setBackgroundColour(ColourValue(1.0f,1.0f,0.8f));
  84. mSceneMgr->setFog(Ogre::FOG_LINEAR,ColourValue(1.0f,1.0f,0.8f),0,15,100);
  86. // set shadow properties
  87. mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE);
  88. mSceneMgr->setShadowColour(ColourValue(0.5,0.5,0.5));
  89. mSceneMgr->setShadowTextureSize(1024);
  90. mSceneMgr->setShadowTextureCount(1);
  92. // disable default camera control so the character can do its own
  93. mCameraMan->setStyle(CS_MANUAL);
  95. // use a small amount of ambient lighting
  96. mSceneMgr->setAmbientLight(ColourValue(0.3,0.3,0.3));
  98. // add a bright light above the scene
  99. Light* light = mSceneMgr->createLight();
  100. light->setType(Light::LT_POINT);
  101. light->setPosition(-10,40,20);
  102. light->setSpecularColour(ColourValue::White);
  104. // create a floor mesh resource
  105. MeshManager::getSingleton().createPlane("floor",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
  106. Plane(Vector3::UNIT_Y,0),200,200,10,10,true,1,10,10,Vector3::UNIT_Z);
  109. // create a floor entity, give it a material, and place it at the origin
  110. Entity* floor = mSceneMgr->createEntity("Floor","floor");
  111. floor->setMaterialName("Examples/Instancing/Misc/Grass");
  112. floor->setCastShadows(false);
  113. mSceneMgr->getRootSceneNode()->attachObject(floor);
  115. // LogManager::getSingleton().logMessage("creating sinbad");
  116. // create our character controller
  117. mChara =newSinbadCharacterController(mCamera);
  119. // LogManager::getSingleton().logMessage("toggling stats");
  120. mTrayMgr->toggleAdvancedFrameStats();
  122. // LogManager::getSingleton().logMessage("creating panel");
  123. StringVector items;
  124. items.push_back("Help");
  125. ParamsPanel* help = mTrayMgr->createParamsPanel(TL_TOPLEFT,"HelpMessage",100, items);
  126. help->setParamValue("Help","H / F1");
  129. // LogManager::getSingleton().logMessage("all done");
  130. }
  132. void cleanupContent()
  133. {
  134. // clean up character controller and the floor mesh
  135. if(mChara)
  136. {
  137. delete mChara;
  138. mChara =0;
  139. }
  140. MeshManager::getSingleton().remove("floor");
  141. }
  143. SinbadCharacterController* mChara;
  145. };
  147. #endif

SinbadCharacterController.h

  1. #ifndef __Sinbad_H__
  2. #define __Sinbad_H__
  4. #include"Ogre.h"
  5. #include"OIS.h"
  6. #include<cstdlib>
  8. usingnamespaceOgre;
  10. #define NUM_ANIMS 13// number of animations the character has
  11. #define CHAR_HEIGHT 5// height of character's center of mass above ground
  12. #define CAM_HEIGHT 2// height of camera above character's center of mass
  13. #define RUN_SPEED 17// character running speed in units per second
  14. #define TURN_SPEED 500.0f// character turning in degrees per second
  15. #define ANIM_FADE_SPEED 7.5f// animation crossfade speed in % of full weight per second
  16. #define JUMP_ACCEL 30.0f// character jump acceleration in upward units per squared second
  17. #define GRAVITY 90.0f// gravity in downward units per squared second
  19. classSinbadCharacterController
  20. {
  21. private:
  23. // all the animations our character has, and a null ID
  24. // some of these affect separate body parts and will be blended together
  25. enumAnimID
  26. {
  27. ANIM_IDLE_BASE,
  28. ANIM_IDLE_TOP,
  29. ANIM_RUN_BASE,
  30. ANIM_RUN_TOP,
  31. ANIM_HANDS_CLOSED,
  32. ANIM_HANDS_RELAXED,
  33. ANIM_DRAW_SWORDS,
  34. ANIM_SLICE_VERTICAL,
  35. ANIM_SLICE_HORIZONTAL,
  36. ANIM_DANCE,
  37. ANIM_JUMP_START,
  38. ANIM_JUMP_LOOP,
  39. ANIM_JUMP_END,
  40. ANIM_NONE
  41. };
  43. public:
  45. SinbadCharacterController(Camera* cam)
  46. {
  47. setupBody(cam->getSceneManager());
  48. setupCamera(cam);
  49. setupAnimations();
  50. }
  52. void addTime(Real deltaTime)
  53. {
  54. updateBody(deltaTime);
  55. updateAnimations(deltaTime);
  56. updateCamera(deltaTime);
  57. }
  59. void injectKeyDown(const OIS::KeyEvent& evt)
  60. {
  61. if(evt.key == OIS::KC_Q &&(mTopAnimID == ANIM_IDLE_TOP || mTopAnimID == ANIM_RUN_TOP))
  62. {
  63. // take swords out (or put them back, since it's the same animation but reversed)
  64. setTopAnimation(ANIM_DRAW_SWORDS,true);
  65. mTimer =0;
  66. }
  67. elseif(evt.key == OIS::KC_E &&!mSwordsDrawn)
  68. {
  69. if(mTopAnimID == ANIM_IDLE_TOP || mTopAnimID == ANIM_RUN_TOP)
  70. {
  71. // start dancing
  72. setBaseAnimation(ANIM_DANCE,true);
  73. setTopAnimation(ANIM_NONE);
  74. // disable hand animation because the dance controls hands
  75. mAnims[ANIM_HANDS_RELAXED]->setEnabled(false);
  76. }
  77. elseif(mBaseAnimID == ANIM_DANCE)
  78. {
  79. // stop dancing
  80. setBaseAnimation(ANIM_IDLE_BASE);
  81. setTopAnimation(ANIM_IDLE_TOP);
  82. // re-enable hand animation
  83. mAnims[ANIM_HANDS_RELAXED]->setEnabled(true);
  84. }
  85. }
  87. // keep track of the player's intended direction
  88. elseif(evt.key == OIS::KC_W) mKeyDirection.z =-1;
  89. elseif(evt.key == OIS::KC_A) mKeyDirection.x =-1;
  90. elseif(evt.key == OIS::KC_S) mKeyDirection.z =1;
  91. elseif(evt.key == OIS::KC_D) mKeyDirection.x =1;
  93. elseif(evt.key == OIS::KC_SPACE &&(mTopAnimID == ANIM_IDLE_TOP || mTopAnimID == ANIM_RUN_TOP))
  94. {
  95. // jump if on ground
  96. setBaseAnimation(ANIM_JUMP_START,true);
  97. setTopAnimation(ANIM_NONE);
  98. mTimer =0;
  99. }
  101. if(!mKeyDirection.isZeroLength()&& mBaseAnimID == ANIM_IDLE_BASE)
  102. {
  103. // start running if not already moving and the player wants to move
  104. setBaseAnimation(ANIM_RUN_BASE,true);
  105. if(mTopAnimID == ANIM_IDLE_TOP) setTopAnimation(ANIM_RUN_TOP,true);
  106. }
  107. }
  109. void injectKeyUp(const OIS::KeyEvent& evt)
  110. {
  111. // keep track of the player's intended direction
  112. if(evt.key == OIS::KC_W && mKeyDirection.z ==-1) mKeyDirection.z =0;
  113. elseif(evt.key == OIS::KC_A && mKeyDirection.x ==-1) mKeyDirection.x =0;
  114. elseif(evt.key == OIS::KC_S && mKeyDirection.z ==1) mKeyDirection.z =0;
  115. elseif(evt.key == OIS::KC_D && mKeyDirection.x ==1) mKeyDirection.x =0;
  117. if(mKeyDirection.isZeroLength()&& mBaseAnimID == ANIM_RUN_BASE)
  118. {
  119. // stop running if already moving and the player doesn't want to move
  120. setBaseAnimation(ANIM_IDLE_BASE);
  121. if(mTopAnimID == ANIM_RUN_TOP) setTopAnimation(ANIM_IDLE_TOP);
  122. }
  123. }
  125. #if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
  126. void injectMouseMove(const OIS::MultiTouchEvent& evt)
  127. {
  128. // update camera goal based on mouse movement
  129. updateCameraGoal(-0.05f* evt.state.X.rel,-0.05f* evt.state.Y.rel,-0.0005f* evt.state.Z.rel);
  130. }
  132. void injectMouseDown(const OIS::MultiTouchEvent& evt)
  133. {
  134. if(mSwordsDrawn &&(mTopAnimID == ANIM_IDLE_TOP || mTopAnimID == ANIM_RUN_TOP))
  135. {
  136. // if swords are out, and character's not doing something weird, then SLICE!
  137. setTopAnimation(ANIM_SLICE_VERTICAL,true);
  138. mTimer =0;
  139. }
  140. }
  141. #else
  142. void injectMouseMove(const OIS::MouseEvent& evt)
  143. {
  144. // update camera goal based on mouse movement
  145. updateCameraGoal(-0.05f* evt.state.X.rel,-0.05f* evt.state.Y.rel,-0.0005f* evt.state.Z.rel);
  146. }
  148. void injectMouseDown(const OIS::MouseEvent& evt, OIS::MouseButtonID id)
  149. {
  150. if(mSwordsDrawn &&(mTopAnimID == ANIM_IDLE_TOP || mTopAnimID == ANIM_RUN_TOP))
  151. {
  152. // if swords are out, and character's not doing something weird, then SLICE!
  153. if(id == OIS::MB_Left) setTopAnimation(ANIM_SLICE_VERTICAL,true);
  154. elseif(id == OIS::MB_Right) setTopAnimation(ANIM_SLICE_HORIZONTAL,true);
  155. mTimer =0;
  156. //碰撞检测
  157. AxisAlignedBox mSword1box = mBodyNode->_getWorldAABB();
  158. AxisAlignedBox robotbox = node->_getWorldAABB();
  159. if(mSword1box.intersects(robotbox))
  160. {
  161. //相交
  162. //dra->setVisible(0);
  163. node->setPosition( rand()%50,0,rand()%50);//rand() % 100,rand() % 100,0);
  164. }
  166. }
  167. }
  168. #endif
  170. private:
  172. void setupBody(SceneManager* sceneMgr)
  173. {
  174. // create main model
  175. mBodyNode = sceneMgr->getRootSceneNode()->createChildSceneNode(Vector3::UNIT_Y * CHAR_HEIGHT);
  176. mBodyEnt = sceneMgr->createEntity("SinbadBody","Sinbad.mesh");
  177. mBodyNode->attachObject(mBodyEnt);
  179. // create swords and attach to sheath
  180. LogManager::getSingleton().logMessage("Creating swords");
  181. mSword1 = sceneMgr->createEntity("SinbadSword1","Sword.mesh");
  182. mSword2 = sceneMgr->createEntity("SinbadSword2","Sword.mesh");
  183. mBodyEnt->attachObjectToBone("Sheath.L", mSword1);
  184. mBodyEnt->attachObjectToBone("Sheath.R", mSword2);
  186. //sceneMgr->getRootSceneNode()->attachObject(sceneMgr->createEntity("Head", "ogrehead.mesh"));
  187. // and finally... omg it's a DRAGON!
  188. dra = sceneMgr->createEntity("Robot","robot.mesh");
  189. //sceneMgr->getRootSceneNode()->attachObject(dra);
  190. node = sceneMgr->getRootSceneNode()->createChildSceneNode("RobotNode",Vector3(20,0,0));
  191. node->attachObject(dra);
  193. node->scale(0.1,0.1,0.1);
  198. LogManager::getSingleton().logMessage("Creating the chains");
  199. // create a couple of ribbon trails for the swords, just for fun
  200. NameValuePairListparams;
  201. params["numberOfChains"]="2";
  202. params["maxElements"]="80";
  203. mSwordTrail =(RibbonTrail*)sceneMgr->createMovableObject("RibbonTrail",&params);
  204. mSwordTrail->setMaterialName("Examples/LightRibbonTrail");
  205. mSwordTrail->setTrailLength(20);
  206. mSwordTrail->setVisible(false);
  207. sceneMgr->getRootSceneNode()->attachObject(mSwordTrail);
  210. for(int i =0; i <2; i++)
  211. {
  212. mSwordTrail->setInitialColour(i,1,0.8,0);
  213. mSwordTrail->setColourChange(i,0.75,1.25,1.25,1.25);
  214. mSwordTrail->setWidthChange(i,1);
  215. mSwordTrail->setInitialWidth(i,0.5);
  216. }
  218. mKeyDirection =Vector3::ZERO;
  219. mVerticalVelocity =0;
  220. }
  222. void setupAnimations()
  223. {
  224. // this is very important due to the nature of the exported animations
  225. mBodyEnt->getSkeleton()->setBlendMode(ANIMBLEND_CUMULATIVE);
  227. String animNames[]=
  228. {"IdleBase","IdleTop","RunBase","RunTop","HandsClosed","HandsRelaxed","DrawSwords",
  229. "SliceVertical","SliceHorizontal","Dance","JumpStart","JumpLoop","JumpEnd"};
  231. // populate our animation list
  232. for(int i =0; i < NUM_ANIMS; i++)
  233. {
  234. mAnims[i]= mBodyEnt->getAnimationState(animNames[i]);
  235. mAnims[i]->setLoop(true);
  236. mFadingIn[i]=false;
  237. mFadingOut[i]=false;
  238. }
  240. // start off in the idle state (top and bottom together)
  241. setBaseAnimation(ANIM_IDLE_BASE);
  242. setTopAnimation(ANIM_IDLE_TOP);
  244. // relax the hands since we're not holding anything
  245. mAnims[ANIM_HANDS_RELAXED]->setEnabled(true);
  247. mSwordsDrawn =false;
  248. }
  250. void setupCamera(Camera* cam)
  251. {
  252. // create a pivot at roughly the character's shoulder
  253. mCameraPivot = cam->getSceneManager()->getRootSceneNode()->createChildSceneNode();
  254. // this is where the camera should be soon, and it spins around the pivot
  255. mCameraGoal = mCameraPivot->createChildSceneNode(Vector3(0,0,15));
  256. // this is where the camera actually is
  257. mCameraNode = cam->getSceneManager()->getRootSceneNode()->createChildSceneNode();
  258. mCameraNode->setPosition(mCameraPivot->getPosition()+ mCameraGoal->getPosition());
  260. mCameraPivot->setFixedYawAxis(true);
  261. mCameraGoal->setFixedYawAxis(true);
  262. mCameraNode->setFixedYawAxis(true);
  264. // our model is quite small, so reduce the clipping planes
  265. cam->setNearClipDistance(0.1);
  266. cam->setFarClipDistance(100);
  267. mCameraNode->attachObject(cam);
  269. mPivotPitch =0;
  270. }
  272. void updateBody(Real deltaTime)
  273. {
  274. mGoalDirection =Vector3::ZERO;// we will calculate this
  276. if(mKeyDirection !=Vector3::ZERO && mBaseAnimID != ANIM_DANCE)
  277. {
  278. // calculate actually goal direction in world based on player's key directions
  279. mGoalDirection += mKeyDirection.z * mCameraNode->getOrientation().zAxis();
  280. mGoalDirection += mKeyDirection.x * mCameraNode->getOrientation().xAxis();
  281. mGoalDirection.y =0;
  282. mGoalDirection.normalise();
  284. Quaternion toGoal = mBodyNode->getOrientation().zAxis().getRotationTo(mGoalDirection);
  286. // calculate how much the character has to turn to face goal direction
  287. Real yawToGoal = toGoal.getYaw().valueDegrees();
  288. // this is how much the character CAN turn this frame
  289. Real yawAtSpeed = yawToGoal /Math::Abs(yawToGoal)* deltaTime * TURN_SPEED;
  290. // reduce "turnability" if we're in midair
  291. if(mBaseAnimID == ANIM_JUMP_LOOP) yawAtSpeed *=0.2f;
  293. // turn as much as we can, but not more than we need to
  294. if(yawToGoal <0) yawToGoal = std::min<Real>(0, std::max<Real>(yawToGoal, yawAtSpeed));//yawToGoal = Math::Clamp<Real>(yawToGoal, yawAtSpeed, 0);
  295. elseif(yawToGoal >0) yawToGoal = std::max<Real>(0, std::min<Real>(yawToGoal, yawAtSpeed));//yawToGoal = Math::Clamp<Real>(yawToGoal, 0, yawAtSpeed);
  297. mBodyNode->yaw(Degree(yawToGoal));
  299. // move in current body direction (not the goal direction)
  300. mBodyNode->translate(0,0, deltaTime * RUN_SPEED * mAnims[mBaseAnimID]->getWeight(),
  301. Node::TS_LOCAL);
  302. }
  304. if(mBaseAnimID == ANIM_JUMP_LOOP)
  305. {
  306. // if we're jumping, add a vertical offset too, and apply gravity
  307. mBodyNode->translate(0, mVerticalVelocity * deltaTime,0,Node::TS_LOCAL);
  308. mVerticalVelocity -= GRAVITY * deltaTime;
  310. Vector3 pos = mBodyNode->getPosition();
  311. if(pos.y <= CHAR_HEIGHT)
  312. {
  313. // if we've hit the ground, change to landing state
  314. pos.y = CHAR_HEIGHT;
  315. mBodyNode->setPosition(pos);
  316. setBaseAnimation(ANIM_JUMP_END,true);
  317. mTimer =0;
  318. }
  319. }
  320. }
  322. void updateAnimations(Real deltaTime)
  323. {
  324. Real baseAnimSpeed =1;
  325. Real topAnimSpeed =1;
  327. mTimer += deltaTime;
  329. if(mTopAnimID == ANIM_DRAW_SWORDS)
  330. {
  331. // flip the draw swords animation if we need to put it back
  332. topAnimSpeed = mSwordsDrawn ?-1:1;
  334. // half-way through the animation is when the hand grasps the handles...
  335. if(mTimer >= mAnims[mTopAnimID]->getLength()/2&&
  336. mTimer - deltaTime < mAnims[mTopAnimID]->getLength()/2)
  337. {
  338. // so transfer the swords from the sheaths to the hands
  339. mBodyEnt->detachAllObjectsFromBone();
  340. mBodyEnt->attachObjectToBone(mSwordsDrawn ?"Sheath.L":"Handle.L", mSword1);
  341. mBodyEnt->attachObjectToBone(mSwordsDrawn ?"Sheath.R":"Handle.R", mSword2);
  342. // change the hand state to grab or let go
  343. mAnims[ANIM_HANDS_CLOSED]->setEnabled(!mSwordsDrawn);
  344. mAnims[ANIM_HANDS_RELAXED]->setEnabled(mSwordsDrawn);
  346. // toggle sword trails
  347. if(mSwordsDrawn)
  348. {
  349. mSwordTrail->setVisible(false);
  350. mSwordTrail->removeNode(mSword1->getParentNode());
  351. mSwordTrail->removeNode(mSword2->getParentNode());
  352. }
  353. else
  354. {
  355. mSwordTrail->setVisible(true);
  356. mSwordTrail->addNode(mSword1->getParentNode());
  357. mSwordTrail->addNode(mSword2->getParentNode());
  358. }
  359. }
  361. if(mTimer >= mAnims[mTopAnimID]->getLength())
  362. {
  363. // animation is finished, so return to what we were doing before
  364. if(mBaseAnimID == ANIM_IDLE_BASE) setTopAnimation(ANIM_IDLE_TOP);
  365. else
  366. {
  367. setTopAnimation(ANIM_RUN_TOP);
  368. mAnims[ANIM_RUN_TOP]->setTimePosition(mAnims[ANIM_RUN_BASE]->getTimePosition());
  369. }
  370. mSwordsDrawn =!mSwordsDrawn;
  371. }
  372. }
  373. elseif(mTopAnimID == ANIM_SLICE_VERTICAL || mTopAnimID == ANIM_SLICE_HORIZONTAL)
  374. {
  375. if(mTimer >= mAnims[mTopAnimID]->getLength())
  376. {
  377. // animation is finished, so return to what we were doing before
  378. if(mBaseAnimID == ANIM_IDLE_BASE) setTopAnimation(ANIM_IDLE_TOP);
  379. else
  380. {
  381. setTopAnimation(ANIM_RUN_TOP);
  382. mAnims[ANIM_RUN_TOP]->setTimePosition(mAnims[ANIM_RUN_BASE]->getTimePosition());
  383. }
  384. }
  386. // don't sway hips from side to side when slicing. that's just embarrassing.
  387. if(mBaseAnimID == ANIM_IDLE_BASE) baseAnimSpeed =0;
  388. }
  389. elseif(mBaseAnimID == ANIM_JUMP_START)
  390. {
  391. if(mTimer >= mAnims[mBaseAnimID]->getLength())
  392. {
  393. // takeoff animation finished, so time to leave the ground!
  394. setBaseAnimation(ANIM_JUMP_LOOP,true);
  395. // apply a jump acceleration to the character
  396. mVerticalVelocity = JUMP_ACCEL;
  397. }
  398. }
  399. elseif(mBaseAnimID == ANIM_JUMP_END)
  400. {
  401. if(mTimer >= mAnims[mBaseAnimID]->getLength())
  402. {
  403. // safely landed, so go back to running or idling
  404. if(mKeyDirection ==Vector3::ZERO)
  405. {
  406. setBaseAnimation(ANIM_IDLE_BASE);
  407. setTopAnimation(ANIM_IDLE_TOP);
  408. }
  409. else
  410. {
  411. setBaseAnimation(ANIM_RUN_BASE,true);
  412. setTopAnimation(ANIM_RUN_TOP,true);
  413. }
  414. }
  415. }
  417. // increment the current base and top animation times
  418. if(mBaseAnimID != ANIM_NONE) mAnims[mBaseAnimID]->addTime(deltaTime * baseAnimSpeed);
  419. if(mTopAnimID != ANIM_NONE) mAnims[mTopAnimID]->addTime(deltaTime * topAnimSpeed);
  421. // apply smooth transitioning between our animations
  422. fadeAnimations(deltaTime);
  423. }
  425. void fadeAnimations(Real deltaTime)
  426. {
  427. for(int i =0; i < NUM_ANIMS; i++)
  428. {
  429. if(mFadingIn[i])
  430. {
  431. // slowly fade this animation in until it has full weight
  432. Real newWeight = mAnims[i]->getWeight()+ deltaTime * ANIM_FADE_SPEED;
  433. mAnims[i]->setWeight(Math::Clamp<Real>(newWeight,0,1));
  434. if(newWeight >=1) mFadingIn[i]=false;
  435. }
  436. elseif(mFadingOut[i])
  437. {
  438. // slowly fade this animation out until it has no weight, and then disable it
  439. Real newWeight = mAnims[i]->getWeight()- deltaTime * ANIM_FADE_SPEED;
  440. mAnims[i]->setWeight(Math::Clamp<Real>(newWeight,0,1));
  441. if(newWeight <=0)
  442. {
  443. mAnims[i]->setEnabled(false);
  444. mFadingOut[i]=false;
  445. }
  446. }
  447. }
  448. }
  450. void updateCamera(Real deltaTime)
  451. {
  452. // place the camera pivot roughly at the character's shoulder
  453. mCameraPivot->setPosition(mBodyNode->getPosition()+Vector3::UNIT_Y * CAM_HEIGHT);
  454. // move the camera smoothly to the goal
  455. Vector3 goalOffset = mCameraGoal->_getDerivedPosition()- mCameraNode->getPosition();
  456. mCameraNode->translate(goalOffset * deltaTime *9.0f);
  457. // always look at the pivot
  458. mCameraNode->lookAt(mCameraPivot->_getDerivedPosition(),Node::TS_WORLD);
  459. }
  461. void updateCameraGoal(Real deltaYaw,Real deltaPitch,Real deltaZoom)
  462. {
  463. mCameraPivot->yaw(Degree(deltaYaw),Node::TS_WORLD);
  465. // bound the pitch
  466. if(!(mPivotPitch + deltaPitch >25&& deltaPitch >0)&&
  467. !(mPivotPitch + deltaPitch <-60&& deltaPitch <0))
  468. {
  469. mCameraPivot->pitch(Degree(deltaPitch),Node::TS_LOCAL);
  470. mPivotPitch += deltaPitch;
  471. }
  473. Real dist = mCameraGoal->_getDerivedPosition().distance(mCameraPivot->_getDerivedPosition());
  474. Real distChange = deltaZoom * dist;
  476. // bound the zoom
  477. if(!(dist + distChange <8&& distChange <0)&&
  478. !(dist + distChange >25&& distChange >0))
  479. {
  480. mCameraGoal->translate(0,0, distChange,Node::TS_LOCAL);
  481. }
  482. }
  484. void setBaseAnimation(AnimID id,bool reset =false)
  485. {
  486. if(mBaseAnimID >=0&& mBaseAnimID < NUM_ANIMS)
  487. {
  488. // if we have an old animation, fade it out
  489. mFadingIn[mBaseAnimID]=false;
  490. mFadingOut[mBaseAnimID]=true;
  491. }
  493. mBaseAnimID = id;
  495. if(id != ANIM_NONE)
  496. {
  497. // if we have a new animation, enable it and fade it in
  498. mAnims[id]->setEnabled(true);
  499. mAnims[id]->setWeight(0);
  500. mFadingOut[id]=false;
  501. mFadingIn[id]=true;
  502. if(reset) mAnims[id]->setTimePosition(0);
  503. }
  504. }
  506. void setTopAnimation(AnimID id,bool reset =false)
  507. {
  508. if(mTopAnimID >=0&& mTopAnimID < NUM_ANIMS)
  509. {
  510. // if we have an old animation, fade it out
  511. mFadingIn[mTopAnimID]=false;
  512. mFadingOut[mTopAnimID]=true;
  513. }
  515. mTopAnimID = id;
  517. if(id != ANIM_NONE)
  518. {
  519. // if we have a new animation, enable it and fade it in
  520. mAnims[id]->setEnabled(true);
  521. mAnims[id]->setWeight(0);
  522. mFadingOut[id]=false;
  523. mFadingIn[id]=true;
  524. if(reset) mAnims[id]->setTimePosition(0);
  525. }
  526. }
  528. SceneNode* mBodyNode;
  529. SceneNode*node;
  530. SceneNode* mCameraPivot;
  531. SceneNode* mCameraGoal;
  532. SceneNode* mCameraNode;
  533. Real mPivotPitch;
  534. Entity* mBodyEnt;
  535. Entity* mSword1;
  536. Entity* mSword2;
  537. Entity* dra;
  538. RibbonTrail* mSwordTrail;
  539. AnimationState* mAnims[NUM_ANIMS];// master animation list
  540. AnimID mBaseAnimID;// current base (full- or lower-body) animation
  541. AnimID mTopAnimID;// current top (upper-body) animation
  542. bool mFadingIn[NUM_ANIMS];// which animations are fading in
  543. bool mFadingOut[NUM_ANIMS];// which animations are fading out
  544. bool mSwordsDrawn;
  545. Vector3 mKeyDirection;// player's local intended direction based on WASD keys
  546. Vector3 mGoalDirection;// actual intended direction in world-space
  547. Real mVerticalVelocity;// for jumping
  548. Real mTimer;// general timer to see how long animations have been playing
  549. };
  551. #endif

CharacterSample.cpp

  1. #include"SamplePlugin.h"
  2. #include"CharacterSample.h"
  4. usingnamespaceOgre;
  5. usingnamespaceOgreBites;
  7. #ifndef OGRE_STATIC_LIB
  9. SamplePlugin* sp;
  10. Sample* s;
  11. Sample* e;
  12. //Sample* s1;
  14. extern"C"_OgreSampleExportvoid dllStartPlugin()
  15. {
  16. s =newSample_Character;
  17. //s1 = new Sample_Character;
  18. //e = new Sample_SkeletalAnimation;
  19. sp = OGRE_NEW SamplePlugin(s->getInfo()["Title"]+" Sample");
  20. sp->addSample(s);
  21. //sp->addSample(s1);
  22. //sp->addSample(e);
  23. Root::getSingleton().installPlugin(sp);
  24. }
  26. extern"C"_OgreSampleExportvoid dllStopPlugin()
  27. {
  28. Root::getSingleton().uninstallPlugin(sp);
  29. OGRE_DELETE sp;
  30. delete s;
  31. //delete s1;
  32. //delete e;
  33. }
  35. #endif

参考资料：

中文OGRE参考网站
OGRE官方文档（英文）
OGRE3D游戏开发框架指南（中文电子书）
[PR]Apress.Pro.OGRE.3D.Programming（英文电子书）

posted @ 2014-04-13 22:28  YUAN园  阅读(783)  评论(0)    收藏  举报