开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llmotioncontroller.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：33k
源码类别：

游戏引擎

开发平台：

C++ Builder

llmotioncontroller.cpp：源码内容
  1. /** 
  2.  * @file llmotioncontroller.cpp
  3.  * @brief Implementation of LLMotionController class.
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. //-----------------------------------------------------------------------------
  34. // Header Files
  35. //-----------------------------------------------------------------------------
  36. #include "linden_common.h"
  38. #include "llmemtype.h"
  40. #include "llmotioncontroller.h"
  41. #include "llkeyframemotion.h"
  42. #include "llmath.h"
  43. #include "lltimer.h"
  44. #include "llanimationstates.h"
  45. #include "llstl.h"
  47. const S32 NUM_JOINT_SIGNATURE_STRIDES = LL_CHARACTER_MAX_JOINTS / 4;
  48. const U32 MAX_MOTION_INSTANCES = 32;
  50. //-----------------------------------------------------------------------------
  51. // Constants and statics
  52. //-----------------------------------------------------------------------------
  53. LLMotionRegistry LLMotionController::sRegistry;
  55. //-----------------------------------------------------------------------------
  56. //-----------------------------------------------------------------------------
  57. // LLMotionRegistry class
  58. //-----------------------------------------------------------------------------
  59. //-----------------------------------------------------------------------------
  61. //-----------------------------------------------------------------------------
  62. // LLMotionRegistry()
  63. // Class Constructor
  64. //-----------------------------------------------------------------------------
  65. LLMotionRegistry::LLMotionRegistry()
  66. {
  68. }
  71. //-----------------------------------------------------------------------------
  72. // ~LLMotionRegistry()
  73. // Class Destructor
  74. //-----------------------------------------------------------------------------
  75. LLMotionRegistry::~LLMotionRegistry()
  76. {
  77. mMotionTable.clear();
  78. }
  81. //-----------------------------------------------------------------------------
  82. // addMotion()
  83. //-----------------------------------------------------------------------------
  84. BOOL LLMotionRegistry::registerMotion( const LLUUID& id, LLMotionConstructor constructor )
  85. {
  86. // llinfos << "Registering motion: " << name << llendl;
  87. if (!is_in_map(mMotionTable, id))
  88. {
  89. mMotionTable[id] = constructor;
  90. return TRUE;
  91. }
  93. return FALSE;
  94. }
  96. //-----------------------------------------------------------------------------
  97. // markBad()
  98. //-----------------------------------------------------------------------------
  99. void LLMotionRegistry::markBad( const LLUUID& id )
  100. {
  101. mMotionTable[id] = LLMotionConstructor(NULL);
  102. }
  104. //-----------------------------------------------------------------------------
  105. // createMotion()
  106. //-----------------------------------------------------------------------------
  107. LLMotion *LLMotionRegistry::createMotion( const LLUUID &id )
  108. {
  109. LLMotionConstructor constructor = get_if_there(mMotionTable, id, LLMotionConstructor(NULL));
  110. LLMotion* motion = NULL;
  112. if ( constructor == NULL )
  113. {
  114. // *FIX: need to replace with a better default scheme. RN
  115. motion = LLKeyframeMotion::create(id);
  116. }
  117. else
  118. {
  119. motion = constructor(id);
  120. }
  122. return motion;
  123. }
  125. //-----------------------------------------------------------------------------
  126. //-----------------------------------------------------------------------------
  127. // LLMotionController class
  128. //-----------------------------------------------------------------------------
  129. //-----------------------------------------------------------------------------
  131. //-----------------------------------------------------------------------------
  132. // LLMotionController()
  133. // Class Constructor
  134. //-----------------------------------------------------------------------------
  135. LLMotionController::LLMotionController()
  136. : mTimeFactor(1.f),
  137.   mCharacter(NULL),
  138.   mAnimTime(0.f),
  139.   mPrevTimerElapsed(0.f),
  140.   mLastTime(0.0f),
  141.   mHasRunOnce(FALSE),
  142.   mPaused(FALSE),
  143.   mPauseTime(0.f),
  144.   mTimeStep(0.f),
  145.   mTimeStepCount(0),
  146.   mLastInterp(0.f)
  147. {
  148. }
  151. //-----------------------------------------------------------------------------
  152. // ~LLMotionController()
  153. // Class Destructor
  154. //-----------------------------------------------------------------------------
  155. LLMotionController::~LLMotionController()
  156. {
  157. deleteAllMotions();
  158. }
  160. void LLMotionController::incMotionCounts(S32& num_motions, S32& num_loading_motions, S32& num_loaded_motions, S32& num_active_motions, S32& num_deprecated_motions)
  161. {
  162. num_motions += mAllMotions.size();
  163. num_loading_motions += mLoadingMotions.size();
  164. num_loaded_motions += mLoadedMotions.size();
  165. num_active_motions += mActiveMotions.size();
  166. num_deprecated_motions += mDeprecatedMotions.size();
  167. }
  169. //-----------------------------------------------------------------------------
  170. // deleteAllMotions()
  171. //-----------------------------------------------------------------------------
  172. void LLMotionController::deleteAllMotions()
  173. {
  174. mLoadingMotions.clear();
  175. mLoadedMotions.clear();
  176. mActiveMotions.clear();
  178. for_each(mAllMotions.begin(), mAllMotions.end(), DeletePairedPointer());
  179. mAllMotions.clear();
  180. }
  182. //-----------------------------------------------------------------------------
  183. // purgeExcessMotion()
  184. //-----------------------------------------------------------------------------
  185. void LLMotionController::purgeExcessMotions()
  186. {
  187. if (mLoadedMotions.size() > MAX_MOTION_INSTANCES)
  188. {
  189. // clean up deprecated motions
  190. for (motion_set_t::iterator deprecated_motion_it = mDeprecatedMotions.begin(); 
  191.  deprecated_motion_it != mDeprecatedMotions.end(); )
  192. {
  193. motion_set_t::iterator cur_iter = deprecated_motion_it++;
  194. LLMotion* cur_motionp = *cur_iter;
  195. if (!isMotionActive(cur_motionp))
  196. {
  197. // Motion is deprecated so we know it's not cannonical,
  198. //  we can safely remove the instance
  199. removeMotionInstance(cur_motionp); // modifies mDeprecatedMotions
  200. mDeprecatedMotions.erase(cur_iter);
  201. }
  202. }
  203. }
  205. std::set<LLUUID> motions_to_kill;
  206. if (mLoadedMotions.size() > MAX_MOTION_INSTANCES)
  207. {
  208. // too many motions active this frame, kill all blenders
  209. mPoseBlender.clearBlenders();
  210. for (motion_set_t::iterator loaded_motion_it = mLoadedMotions.begin(); 
  211.  loaded_motion_it != mLoadedMotions.end(); 
  212.  ++loaded_motion_it)
  213. {
  214. LLMotion* cur_motionp = *loaded_motion_it;
  215. // motion isn't playing, delete it
  216. if (!isMotionActive(cur_motionp))
  217. {
  218. motions_to_kill.insert(cur_motionp->getID());
  219. }
  220. }
  221. }
  223. // clean up all inactive, loaded motions
  224. for (std::set<LLUUID>::iterator motion_it = motions_to_kill.begin();
  225. motion_it != motions_to_kill.end();
  226. ++motion_it)
  227. {
  228. // look up the motion again by ID to get canonical instance
  229. // and kill it only if that one is inactive
  230. LLUUID motion_id = *motion_it;
  231. LLMotion* motionp = findMotion(motion_id);
  232. if (motionp && !isMotionActive(motionp))
  233. {
  234. removeMotion(motion_id);
  235. }
  236. }
  238. if (mLoadedMotions.size() > 2*MAX_MOTION_INSTANCES)
  239. {
  240. LL_WARNS_ONCE("Animation") << "> " << 2*MAX_MOTION_INSTANCES << " Loaded Motions" << llendl;
  241. }
  242. }
  244. //-----------------------------------------------------------------------------
  245. // deactivateStoppedMotions()
  246. //-----------------------------------------------------------------------------
  247. void LLMotionController::deactivateStoppedMotions()
  248. {
  249. // Since we're hidden, deactivate any stopped motions.
  250. for (motion_list_t::iterator iter = mActiveMotions.begin();
  251.  iter != mActiveMotions.end(); )
  252. {
  253. motion_list_t::iterator curiter = iter++;
  254. LLMotion* motionp = *curiter;
  255. if (motionp->isStopped())
  256. {
  257. deactivateMotionInstance(motionp);
  258. }
  259. }
  260. }
  262. //-----------------------------------------------------------------------------
  263. // setTimeStep()
  264. //-----------------------------------------------------------------------------
  265. void LLMotionController::setTimeStep(F32 step)
  266. {
  267. mTimeStep = step;
  269. if (step != 0.f)
  270. {
  271. // make sure timestamps conform to new quantum
  272. for (motion_list_t::iterator iter = mActiveMotions.begin();
  273.  iter != mActiveMotions.end(); ++iter)
  274. {
  275. LLMotion* motionp = *iter;
  276. F32 activation_time = motionp->mActivationTimestamp;
  277. motionp->mActivationTimestamp = (F32)(llfloor(activation_time / step)) * step;
  278. BOOL stopped = motionp->isStopped();
  279. motionp->setStopTime((F32)(llfloor(motionp->getStopTime() / step)) * step);
  280. motionp->setStopped(stopped);
  281. motionp->mSendStopTimestamp = (F32)llfloor(motionp->mSendStopTimestamp / step) * step;
  282. }
  283. }
  284. }
  286. //-----------------------------------------------------------------------------
  287. // setTimeFactor()
  288. //-----------------------------------------------------------------------------
  289. void LLMotionController::setTimeFactor(F32 time_factor)
  290. { 
  291. mTimeFactor = time_factor; 
  292. }
  294. //-----------------------------------------------------------------------------
  295. // setCharacter()
  296. //-----------------------------------------------------------------------------
  297. void LLMotionController::setCharacter(LLCharacter *character)
  298. {
  299. mCharacter = character;
  300. }
  303. //-----------------------------------------------------------------------------
  304. // registerMotion()
  305. //-----------------------------------------------------------------------------
  306. BOOL LLMotionController::registerMotion( const LLUUID& id, LLMotionConstructor constructor )
  307. {
  308. return sRegistry.registerMotion(id, constructor);
  309. }
  311. //-----------------------------------------------------------------------------
  312. // removeMotion()
  313. //-----------------------------------------------------------------------------
  314. void LLMotionController::removeMotion( const LLUUID& id)
  315. {
  316. LLMotion* motionp = findMotion(id);
  317. mAllMotions.erase(id);
  318. removeMotionInstance(motionp);
  319. }
  321. // removes instance of a motion from all runtime structures, but does
  322. // not erase entry by ID, as this could be a duplicate instance
  323. // use removeMotion(id) to remove all references to a given motion by id.
  324. void LLMotionController::removeMotionInstance(LLMotion* motionp)
  325. {
  326. if (motionp)
  327. {
  328. llassert(findMotion(motionp->getID()) != motionp);
  329. if (motionp->isActive())
  330. motionp->deactivate();
  331. mLoadingMotions.erase(motionp);
  332. mLoadedMotions.erase(motionp);
  333. mActiveMotions.remove(motionp);
  334. delete motionp;
  335. }
  336. }
  338. //-----------------------------------------------------------------------------
  339. // createMotion()
  340. //-----------------------------------------------------------------------------
  341. LLMotion* LLMotionController::createMotion( const LLUUID &id )
  342. {
  343. LLMemType mt(LLMemType::MTYPE_ANIMATION);
  344. // do we have an instance of this motion for this character?
  345. LLMotion *motion = findMotion(id);
  347. // if not, we need to create one
  348. if (!motion)
  349. {
  350. // look up constructor and create it
  351. motion = sRegistry.createMotion(id);
  352. if (!motion)
  353. {
  354. return NULL;
  355. }
  357. // look up name for default motions
  358. const char* motion_name = gAnimLibrary.animStateToString(id);
  359. if (motion_name)
  360. {
  361. motion->setName(motion_name);
  362. }
  364. // initialize the new instance
  365. LLMotion::LLMotionInitStatus stat = motion->onInitialize(mCharacter);
  366. switch(stat)
  367. {
  368. case LLMotion::STATUS_FAILURE:
  369. llinfos << "Motion " << id << " init failed." << llendl;
  370. sRegistry.markBad(id);
  371. delete motion;
  372. return NULL;
  373. case LLMotion::STATUS_HOLD:
  374. mLoadingMotions.insert(motion);
  375. break;
  376. case LLMotion::STATUS_SUCCESS:
  377.     // add motion to our list
  378.     mLoadedMotions.insert(motion);
  379. break;
  380. default:
  381. llerrs << "Invalid initialization status" << llendl;
  382. break;
  383. }
  385. mAllMotions[id] = motion;
  386. }
  387. return motion;
  388. }
  390. //-----------------------------------------------------------------------------
  391. // startMotion()
  392. //-----------------------------------------------------------------------------
  393. BOOL LLMotionController::startMotion(const LLUUID &id, F32 start_offset)
  394. {
  395. // do we have an instance of this motion for this character?
  396. LLMotion *motion = findMotion(id);
  398. // motion that is stopping will be allowed to stop but
  399. // replaced by a new instance of that motion
  400. if (motion
  401. && !mPaused
  402. && motion->canDeprecate()
  403. && motion->getFadeWeight() > 0.01f // not LOD-ed out
  404. && (motion->isBlending() || motion->getStopTime() != 0.f))
  405. {
  406. deprecateMotionInstance(motion);
  407. // force creation of new instance
  408. motion = NULL;
  409. }
  411. // create new motion instance
  412. if (!motion)
  413. {
  414. motion = createMotion(id);
  415. }
  417. if (!motion)
  418. {
  419. return FALSE;
  420. }
  421. //if the motion is already active and allows deprecation, then let it keep playing
  422. else if (motion->canDeprecate() && isMotionActive(motion))
  423. {
  424. return TRUE;
  425. }
  427. // llinfos << "Starting motion " << name << llendl;
  428. return activateMotionInstance(motion, mAnimTime - start_offset);
  429. }
  432. //-----------------------------------------------------------------------------
  433. // stopMotionLocally()
  434. //-----------------------------------------------------------------------------
  435. BOOL LLMotionController::stopMotionLocally(const LLUUID &id, BOOL stop_immediate)
  436. {
  437. // if already inactive, return false
  438. LLMotion *motion = findMotion(id);
  439. return stopMotionInstance(motion, stop_immediate);
  440. }
  442. BOOL LLMotionController::stopMotionInstance(LLMotion* motion, BOOL stop_immediate)
  443. {
  444. if (!motion)
  445. {
  446. return FALSE;
  447. }
  449. // If on active list, stop it
  450. if (isMotionActive(motion) && !motion->isStopped())
  451. {
  452. motion->setStopTime(mAnimTime);
  453. if (stop_immediate)
  454. {
  455. deactivateMotionInstance(motion);
  456. }
  457. return TRUE;
  458. }
  459. else if (isMotionLoading(motion))
  460. {
  461. motion->setStopped(TRUE);
  462. return TRUE;
  463. }
  465. return FALSE;
  466. }
  468. //-----------------------------------------------------------------------------
  469. // updateRegularMotions()
  470. //-----------------------------------------------------------------------------
  471. void LLMotionController::updateRegularMotions()
  472. {
  473. updateMotionsByType(LLMotion::NORMAL_BLEND);
  474. }
  476. //-----------------------------------------------------------------------------
  477. // updateAdditiveMotions()
  478. //-----------------------------------------------------------------------------
  479. void LLMotionController::updateAdditiveMotions()
  480. {
  481. updateMotionsByType(LLMotion::ADDITIVE_BLEND);
  482. }
  484. //-----------------------------------------------------------------------------
  485. // resetJointSignatures()
  486. //-----------------------------------------------------------------------------
  487. void LLMotionController::resetJointSignatures()
  488. {
  489. memset(&mJointSignature[0][0], 0, sizeof(U8) * LL_CHARACTER_MAX_JOINTS);
  490. memset(&mJointSignature[1][0], 0, sizeof(U8) * LL_CHARACTER_MAX_JOINTS);
  491. }
  493. //-----------------------------------------------------------------------------
  494. // updateIdleMotion()
  495. // minimal updates for active motions
  496. //-----------------------------------------------------------------------------
  497. void LLMotionController::updateIdleMotion(LLMotion* motionp)
  498. {
  499. if (motionp->isStopped() && mAnimTime > motionp->getStopTime() + motionp->getEaseOutDuration())
  500. {
  501. deactivateMotionInstance(motionp);
  502. }
  503. else if (motionp->isStopped() && mAnimTime > motionp->getStopTime())
  504. {
  505. // is this the first iteration in the ease out phase?
  506. if (mLastTime <= motionp->getStopTime())
  507. {
  508. // store residual weight for this motion
  509. motionp->mResidualWeight = motionp->getPose()->getWeight();
  510. }
  511. }
  512. else if (mAnimTime > motionp->mSendStopTimestamp)
  513. {
  514. // notify character of timed stop event on first iteration past sendstoptimestamp
  515. // this will only be called when an animation stops itself (runs out of time)
  516. if (mLastTime <= motionp->mSendStopTimestamp)
  517. {
  518. mCharacter->requestStopMotion( motionp );
  519. stopMotionInstance(motionp, FALSE);
  520. }
  521. }
  522. else if (mAnimTime >= motionp->mActivationTimestamp)
  523. {
  524. if (mLastTime < motionp->mActivationTimestamp)
  525. {
  526. motionp->mResidualWeight = motionp->getPose()->getWeight();
  527. }
  528. }
  529. }
  531. //-----------------------------------------------------------------------------
  532. // updateIdleActiveMotions()
  533. // Call this instead of updateMotionsByType for hidden avatars
  534. //-----------------------------------------------------------------------------
  535. void LLMotionController::updateIdleActiveMotions()
  536. {
  537. for (motion_list_t::iterator iter = mActiveMotions.begin();
  538.  iter != mActiveMotions.end(); )
  539. {
  540. motion_list_t::iterator curiter = iter++;
  541. LLMotion* motionp = *curiter;
  542. updateIdleMotion(motionp);
  543. }
  544. }
  546. //-----------------------------------------------------------------------------
  547. // updateMotionsByType()
  548. //-----------------------------------------------------------------------------
  549. void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_type)
  550. {
  551. BOOL update_result = TRUE;
  552. U8 last_joint_signature[LL_CHARACTER_MAX_JOINTS];
  554. memset(&last_joint_signature, 0, sizeof(U8) * LL_CHARACTER_MAX_JOINTS);
  556. // iterate through active motions in chronological order
  557. for (motion_list_t::iterator iter = mActiveMotions.begin();
  558.  iter != mActiveMotions.end(); )
  559. {
  560. motion_list_t::iterator curiter = iter++;
  561. LLMotion* motionp = *curiter;
  562. if (motionp->getBlendType() != anim_type)
  563. {
  564. continue;
  565. }
  567. BOOL update_motion = FALSE;
  569. if (motionp->getPose()->getWeight() < 1.f)
  570. {
  571. update_motion = TRUE;
  572. }
  573. else
  574. {
  575. // NUM_JOINT_SIGNATURE_STRIDES should be multiple of 4
  576. for (S32 i = 0; i < NUM_JOINT_SIGNATURE_STRIDES; i++)
  577. {
  578.   U32 *current_signature = (U32*)&(mJointSignature[0][i * 4]);
  579. U32 test_signature = *(U32*)&(motionp->mJointSignature[0][i * 4]);
  581. if ((*current_signature | test_signature) > (*current_signature))
  582. {
  583. *current_signature |= test_signature;
  584. update_motion = TRUE;
  585. }
  587. *((U32*)&last_joint_signature[i * 4]) = *(U32*)&(mJointSignature[1][i * 4]);
  588. current_signature = (U32*)&(mJointSignature[1][i * 4]);
  589. test_signature = *(U32*)&(motionp->mJointSignature[1][i * 4]);
  591. if ((*current_signature | test_signature) > (*current_signature))
  592. {
  593. *current_signature |= test_signature;
  594. update_motion = TRUE;
  595. }
  596. }
  597. }
  599. if (!update_motion)
  600. {
  601. updateIdleMotion(motionp);
  602. continue;
  603. }
  605. LLPose *posep = motionp->getPose();
  607. // only filter by LOD after running every animation at least once (to prime the avatar state)
  608. if (mHasRunOnce && motionp->getMinPixelArea() > mCharacter->getPixelArea())
  609. {
  610. motionp->fadeOut();
  612. //should we notify the simulator that this motion should be stopped (check even if skipped by LOD logic)
  613. if (mAnimTime > motionp->mSendStopTimestamp)
  614. {
  615. // notify character of timed stop event on first iteration past sendstoptimestamp
  616. // this will only be called when an animation stops itself (runs out of time)
  617. if (mLastTime <= motionp->mSendStopTimestamp)
  618. {
  619. mCharacter->requestStopMotion( motionp );
  620. stopMotionInstance(motionp, FALSE);
  621. }
  622. }
  624. if (motionp->getFadeWeight() < 0.01f)
  625. {
  626. if (motionp->isStopped() && mAnimTime > motionp->getStopTime() + motionp->getEaseOutDuration())
  627. {
  628. posep->setWeight(0.f);
  629. deactivateMotionInstance(motionp);
  630. }
  631. continue;
  632. }
  633. }
  634. else
  635. {
  636. motionp->fadeIn();
  637. }
  639. //**********************
  640. // MOTION INACTIVE
  641. //**********************
  642. if (motionp->isStopped() && mAnimTime > motionp->getStopTime() + motionp->getEaseOutDuration())
  643. {
  644. // this motion has gone on too long, deactivate it
  645. // did we have a chance to stop it?
  646. if (mLastTime <= motionp->getStopTime())
  647. {
  648. // if not, let's stop it this time through and deactivate it the next
  650. posep->setWeight(motionp->getFadeWeight());
  651. motionp->onUpdate(motionp->getStopTime() - motionp->mActivationTimestamp, last_joint_signature);
  652. }
  653. else
  654. {
  655. posep->setWeight(0.f);
  656. deactivateMotionInstance(motionp);
  657. continue;
  658. }
  659. }
  661. //**********************
  662. // MOTION EASE OUT
  663. //**********************
  664. else if (motionp->isStopped() && mAnimTime > motionp->getStopTime())
  665. {
  666. // is this the first iteration in the ease out phase?
  667. if (mLastTime <= motionp->getStopTime())
  668. {
  669. // store residual weight for this motion
  670. motionp->mResidualWeight = motionp->getPose()->getWeight();
  671. }
  673. if (motionp->getEaseOutDuration() == 0.f)
  674. {
  675. posep->setWeight(0.f);
  676. }
  677. else
  678. {
  679. posep->setWeight(motionp->getFadeWeight() * motionp->mResidualWeight * cubic_step(1.f - ((mAnimTime - motionp->getStopTime()) / motionp->getEaseOutDuration())));
  680. }
  682. // perform motion update
  683. update_result = motionp->onUpdate(mAnimTime - motionp->mActivationTimestamp, last_joint_signature);
  684. }
  686. //**********************
  687. // MOTION ACTIVE
  688. //**********************
  689. else if (mAnimTime > motionp->mActivationTimestamp + motionp->getEaseInDuration())
  690. {
  691. posep->setWeight(motionp->getFadeWeight());
  693. //should we notify the simulator that this motion should be stopped?
  694. if (mAnimTime > motionp->mSendStopTimestamp)
  695. {
  696. // notify character of timed stop event on first iteration past sendstoptimestamp
  697. // this will only be called when an animation stops itself (runs out of time)
  698. if (mLastTime <= motionp->mSendStopTimestamp)
  699. {
  700. mCharacter->requestStopMotion( motionp );
  701. stopMotionInstance(motionp, FALSE);
  702. }
  703. }
  705. // perform motion update
  706. update_result = motionp->onUpdate(mAnimTime - motionp->mActivationTimestamp, last_joint_signature);
  707. }
  709. //**********************
  710. // MOTION EASE IN
  711. //**********************
  712. else if (mAnimTime >= motionp->mActivationTimestamp)
  713. {
  714. if (mLastTime < motionp->mActivationTimestamp)
  715. {
  716. motionp->mResidualWeight = motionp->getPose()->getWeight();
  717. }
  718. if (motionp->getEaseInDuration() == 0.f)
  719. {
  720. posep->setWeight(motionp->getFadeWeight());
  721. }
  722. else
  723. {
  724. // perform motion update
  725. posep->setWeight(motionp->getFadeWeight() * motionp->mResidualWeight + (1.f - motionp->mResidualWeight) * cubic_step((mAnimTime - motionp->mActivationTimestamp) / motionp->getEaseInDuration()));
  726. }
  727. // perform motion update
  728. update_result = motionp->onUpdate(mAnimTime - motionp->mActivationTimestamp, last_joint_signature);
  729. }
  730. else
  731. {
  732. posep->setWeight(0.f);
  733. update_result = motionp->onUpdate(0.f, last_joint_signature);
  734. }
  736. // allow motions to deactivate themselves 
  737. if (!update_result)
  738. {
  739. if (!motionp->isStopped() || motionp->getStopTime() > mAnimTime)
  740. {
  741. // animation has stopped itself due to internal logic
  742. // propagate this to the network
  743. // as not all viewers are guaranteed to have access to the same logic
  744. mCharacter->requestStopMotion( motionp );
  745. stopMotionInstance(motionp, FALSE);
  746. }
  748. }
  750. // even if onupdate returns FALSE, add this motion in to the blend one last time
  751. mPoseBlender.addMotion(motionp);
  752. }
  753. }
  755. //-----------------------------------------------------------------------------
  756. // updateLoadingMotions()
  757. //-----------------------------------------------------------------------------
  758. void LLMotionController::updateLoadingMotions()
  759. {
  760. // query pending motions for completion
  761. for (motion_set_t::iterator iter = mLoadingMotions.begin();
  762.  iter != mLoadingMotions.end(); )
  763. {
  764. motion_set_t::iterator curiter = iter++;
  765. LLMotion* motionp = *curiter;
  766. if( !motionp)
  767. {
  768. continue; // maybe shouldn't happen but i've seen it -MG
  769. }
  770. LLMotion::LLMotionInitStatus status = motionp->onInitialize(mCharacter);
  771. if (status == LLMotion::STATUS_SUCCESS)
  772. {
  773. mLoadingMotions.erase(curiter);
  774. // add motion to our loaded motion list
  775. mLoadedMotions.insert(motionp);
  776. // this motion should be playing
  777. if (!motionp->isStopped())
  778. {
  779. activateMotionInstance(motionp, mAnimTime);
  780. }
  781. }
  782. else if (status == LLMotion::STATUS_FAILURE)
  783. {
  784. llinfos << "Motion " << motionp->getID() << " init failed." << llendl;
  785. sRegistry.markBad(motionp->getID());
  786. mLoadingMotions.erase(curiter);
  787. motion_set_t::iterator found_it = mDeprecatedMotions.find(motionp);
  788. if (found_it != mDeprecatedMotions.end())
  789. {
  790. mDeprecatedMotions.erase(found_it);
  791. }
  792. mAllMotions.erase(motionp->getID());
  793. delete motionp;
  794. }
  795. }
  796. }
  798. //-----------------------------------------------------------------------------
  799. // call updateMotion() or updateMotionsMinimal() every frame
  800. //-----------------------------------------------------------------------------
  802. //-----------------------------------------------------------------------------
  803. // updateMotion()
  804. //-----------------------------------------------------------------------------
  805. void LLMotionController::updateMotions(bool force_update)
  806. {
  807. BOOL use_quantum = (mTimeStep != 0.f);
  809. // Always update mPrevTimerElapsed
  810. F32 cur_time = mTimer.getElapsedTimeF32();
  811. F32 delta_time = cur_time - mPrevTimerElapsed;
  812. mPrevTimerElapsed = cur_time;
  813. mLastTime = mAnimTime;
  815. // Always cap the number of loaded motions
  816. purgeExcessMotions();
  818. // Update timing info for this time step.
  819. if (!mPaused)
  820. {
  821. F32 update_time = mAnimTime + delta_time * mTimeFactor;
  822. if (use_quantum)
  823. {
  824. F32 time_interval = fmodf(update_time, mTimeStep);
  826. // always animate *ahead* of actual time
  827. S32 quantum_count = llmax(0, llfloor((update_time - time_interval) / mTimeStep)) + 1;
  828. if (quantum_count == mTimeStepCount)
  829. {
  830. // we're still in same time quantum as before, so just interpolate and exit
  831. if (!mPaused)
  832. {
  833. F32 interp = time_interval / mTimeStep;
  834. mPoseBlender.interpolate(interp - mLastInterp);
  835. mLastInterp = interp;
  836. }
  838. updateLoadingMotions();
  839. return;
  840. }
  842. // is calculating a new keyframe pose, make sure the last one gets applied
  843. mPoseBlender.interpolate(1.f);
  844. clearBlenders();
  846. mTimeStepCount = quantum_count;
  847. mAnimTime = (F32)quantum_count * mTimeStep;
  848. mLastInterp = 0.f;
  849. }
  850. else
  851. {
  852. mAnimTime = update_time;
  853. }
  854. }
  856. updateLoadingMotions();
  858. resetJointSignatures();
  860. if (mPaused && !force_update)
  861. {
  862. updateIdleActiveMotions();
  863. }
  864. else
  865. {
  866. // update additive motions
  867. updateAdditiveMotions();
  868. resetJointSignatures();
  870. // update all regular motions
  871. updateRegularMotions();
  873. if (use_quantum)
  874. {
  875. mPoseBlender.blendAndCache(TRUE);
  876. }
  877. else
  878. {
  879. mPoseBlender.blendAndApply();
  880. }
  881. }
  883. mHasRunOnce = TRUE;
  884. // llinfos << "Motion controller time " << motionTimer.getElapsedTimeF32() << llendl;
  885. }
  887. //-----------------------------------------------------------------------------
  888. // updateMotionsMinimal()
  889. // minimal update (e.g. while hidden)
  890. //-----------------------------------------------------------------------------
  891. void LLMotionController::updateMotionsMinimal()
  892. {
  893. // Always update mPrevTimerElapsed
  894. mPrevTimerElapsed = mTimer.getElapsedTimeF32();
  896. purgeExcessMotions();
  897. updateLoadingMotions();
  898. resetJointSignatures();
  900. deactivateStoppedMotions();
  902. mHasRunOnce = TRUE;
  903. }
  905. //-----------------------------------------------------------------------------
  906. // activateMotionInstance()
  907. //-----------------------------------------------------------------------------
  908. BOOL LLMotionController::activateMotionInstance(LLMotion *motion, F32 time)
  909. {
  910. // It's not clear why the getWeight() line seems to be crashing this, but
  911. // hopefully this fixes it.
  912. if (motion == NULL || motion->getPose() == NULL)
  913. {
  914. return FALSE;
  915. }
  917. if (mLoadingMotions.find(motion) != mLoadingMotions.end())
  918. {
  919. // we want to start this motion, but we can't yet, so flag it as started
  920. motion->setStopped(FALSE);
  921. // report pending animations as activated
  922. return TRUE;
  923. }
  925. motion->mResidualWeight = motion->getPose()->getWeight();
  927. // set stop time based on given duration and ease out time
  928. if (motion->getDuration() != 0.f && !motion->getLoop())
  929. {
  930. F32 ease_out_time;
  931. F32 motion_duration;
  933. // should we stop at the end of motion duration, or a bit earlier 
  934. // to allow it to ease out while moving?
  935. ease_out_time = motion->getEaseOutDuration();
  937. // is the clock running when the motion is easing in?
  938. // if not (POSTURE_EASE) then we need to wait that much longer before triggering the stop
  939. motion_duration = llmax(motion->getDuration() - ease_out_time, 0.f);
  940. motion->mSendStopTimestamp = time + motion_duration;
  941. } 
  942. else
  943. {
  944. motion->mSendStopTimestamp = F32_MAX;
  945. }
  947. if (motion->isActive())
  948. {
  949. mActiveMotions.remove(motion);
  950. }
  951. mActiveMotions.push_front(motion);
  953. motion->activate(time);
  954. motion->onUpdate(0.f, mJointSignature[1]);
  956. if (mAnimTime >= motion->mSendStopTimestamp)
  957. {
  958. motion->setStopTime(motion->mSendStopTimestamp);
  959. if (motion->mResidualWeight == 0.0f)
  960. {
  961. // bit of a hack; if newly activating a motion while easing out, weight should = 1
  962. motion->mResidualWeight = 1.f;
  963. }
  964. }
  966. return TRUE;
  967. }
  969. //-----------------------------------------------------------------------------
  970. // deactivateMotionInstance()
  971. //-----------------------------------------------------------------------------
  972. BOOL LLMotionController::deactivateMotionInstance(LLMotion *motion)
  973. {
  974. motion->deactivate();
  976. motion_set_t::iterator found_it = mDeprecatedMotions.find(motion);
  977. if (found_it != mDeprecatedMotions.end())
  978. {
  979. // deprecated motions need to be completely excised
  980. removeMotionInstance(motion);
  981. mDeprecatedMotions.erase(found_it);
  982. }
  983. else
  984. {
  985. // for motions that we are keeping, simply remove from active queue
  986. mActiveMotions.remove(motion);
  987. }
  989. return TRUE;
  990. }
  992. void LLMotionController::deprecateMotionInstance(LLMotion* motion)
  993. {
  994. mDeprecatedMotions.insert(motion);
  996. //fade out deprecated motion
  997. stopMotionInstance(motion, FALSE);
  998. //no longer canonical
  999. mAllMotions.erase(motion->getID());
  1000. }
  1002. //-----------------------------------------------------------------------------
  1003. // isMotionActive()
  1004. //-----------------------------------------------------------------------------
  1005. bool LLMotionController::isMotionActive(LLMotion *motion)
  1006. {
  1007. return (motion && motion->isActive());
  1008. }
  1010. //-----------------------------------------------------------------------------
  1011. // isMotionLoading()
  1012. //-----------------------------------------------------------------------------
  1013. bool LLMotionController::isMotionLoading(LLMotion* motion)
  1014. {
  1015. return (mLoadingMotions.find(motion) != mLoadingMotions.end());
  1016. }
  1019. //-----------------------------------------------------------------------------
  1020. // findMotion()
  1021. //-----------------------------------------------------------------------------
  1022. LLMotion* LLMotionController::findMotion(const LLUUID& id) const
  1023. {
  1024. motion_map_t::const_iterator iter = mAllMotions.find(id);
  1025. if(iter == mAllMotions.end())
  1026. {
  1027. return NULL;
  1028. }
  1029. else
  1030. {
  1031. return iter->second;
  1032. }
  1033. }
  1035. //-----------------------------------------------------------------------------
  1036. // deactivateAllMotions()
  1037. //-----------------------------------------------------------------------------
  1038. void LLMotionController::deactivateAllMotions()
  1039. {
  1040. for (motion_map_t::iterator iter = mAllMotions.begin();
  1041.  iter != mAllMotions.end(); iter++)
  1042. {
  1043. LLMotion* motionp = iter->second;
  1044. deactivateMotionInstance(motionp);
  1045. }
  1046. }
  1049. //-----------------------------------------------------------------------------
  1050. // flushAllMotions()
  1051. //-----------------------------------------------------------------------------
  1052. void LLMotionController::flushAllMotions()
  1053. {
  1054. std::vector<std::pair<LLUUID,F32> > active_motions;
  1055. active_motions.reserve(mActiveMotions.size());
  1056. for (motion_list_t::iterator iter = mActiveMotions.begin();
  1057.  iter != mActiveMotions.end(); )
  1058. {
  1059. motion_list_t::iterator curiter = iter++;
  1060. LLMotion* motionp = *curiter;
  1061. F32 dtime = mAnimTime - motionp->mActivationTimestamp;
  1062. active_motions.push_back(std::make_pair(motionp->getID(),dtime));
  1063. motionp->deactivate(); // don't call deactivateMotionInstance() because we are going to reactivate it
  1064. }
  1065.   mActiveMotions.clear();
  1067. // delete all motion instances
  1068. deleteAllMotions();
  1070. // kill current hand pose that was previously called out by
  1071. // keyframe motion
  1072. mCharacter->removeAnimationData("Hand Pose");
  1074. // restart motions
  1075. for (std::vector<std::pair<LLUUID,F32> >::iterator iter = active_motions.begin();
  1076.  iter != active_motions.end(); ++iter)
  1077. {
  1078. startMotion(iter->first, iter->second);
  1079. }
  1080. }
  1082. //-----------------------------------------------------------------------------
  1083. // pause()
  1084. //-----------------------------------------------------------------------------
  1085. void LLMotionController::pauseAllMotions()
  1086. {
  1087. if (!mPaused)
  1088. {
  1089. //llinfos << "Pausing animations..." << llendl;
  1090. mPaused = TRUE;
  1091. }
  1093. }
  1095. //-----------------------------------------------------------------------------
  1096. // unpause()
  1097. //-----------------------------------------------------------------------------
  1098. void LLMotionController::unpauseAllMotions()
  1099. {
  1100. if (mPaused)
  1101. {
  1102. //llinfos << "Unpausing animations..." << llendl;
  1103. mPaused = FALSE;
  1104. }
  1105. }
  1106. // End