llpose.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:16k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llpose.cpp
  3.  * @brief Implementation of LLPose 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.  */
  32. //-----------------------------------------------------------------------------
  33. // Header Files
  34. //-----------------------------------------------------------------------------
  35. #include "linden_common.h"
  36. #include "llpose.h"
  37. #include "llmotion.h"
  38. #include "llmath.h"
  39. #include "llstl.h"
  40. //-----------------------------------------------------------------------------
  41. // Static
  42. //-----------------------------------------------------------------------------
  43. //-----------------------------------------------------------------------------
  44. // LLPose
  45. //-----------------------------------------------------------------------------
  46. LLPose::~LLPose()
  47. {
  48. }
  49. //-----------------------------------------------------------------------------
  50. // getFirstJointState()
  51. //-----------------------------------------------------------------------------
  52. LLJointState* LLPose::getFirstJointState()
  53. {
  54. mListIter = mJointMap.begin();
  55. if (mListIter == mJointMap.end())
  56. {
  57. return NULL;
  58. }
  59. else
  60. {
  61. return mListIter->second;
  62. }
  63. }
  64. //-----------------------------------------------------------------------------
  65. // getNextJointState()
  66. //-----------------------------------------------------------------------------
  67. LLJointState *LLPose::getNextJointState()
  68. {
  69. mListIter++;
  70. if (mListIter == mJointMap.end())
  71. {
  72. return NULL;
  73. }
  74. else
  75. {
  76. return mListIter->second;
  77. }
  78. }
  79. //-----------------------------------------------------------------------------
  80. // addJointState()
  81. //-----------------------------------------------------------------------------
  82. BOOL LLPose::addJointState(const LLPointer<LLJointState>& jointState)
  83. {
  84. if (mJointMap.find(jointState->getJoint()->getName()) == mJointMap.end())
  85. {
  86. mJointMap[jointState->getJoint()->getName()] = jointState;
  87. }
  88. return TRUE;
  89. }
  90. //-----------------------------------------------------------------------------
  91. // removeJointState()
  92. //-----------------------------------------------------------------------------
  93. BOOL LLPose::removeJointState(const LLPointer<LLJointState>& jointState)
  94. {
  95. mJointMap.erase(jointState->getJoint()->getName());
  96. return TRUE;
  97. }
  98. //-----------------------------------------------------------------------------
  99. // removeAllJointStates()
  100. //-----------------------------------------------------------------------------
  101. BOOL LLPose::removeAllJointStates()
  102. {
  103. mJointMap.clear();
  104. return TRUE;
  105. }
  106. //-----------------------------------------------------------------------------
  107. // findJointState()
  108. //-----------------------------------------------------------------------------
  109. LLJointState* LLPose::findJointState(LLJoint *joint)
  110. {
  111. joint_map_iterator iter = mJointMap.find(joint->getName());
  112. if (iter == mJointMap.end())
  113. {
  114. return NULL;
  115. }
  116. else
  117. {
  118. return iter->second;
  119. }
  120. }
  121. //-----------------------------------------------------------------------------
  122. // findJointState()
  123. //-----------------------------------------------------------------------------
  124. LLJointState* LLPose::findJointState(const std::string &name)
  125. {
  126. joint_map_iterator iter = mJointMap.find(name);
  127. if (iter == mJointMap.end())
  128. {
  129. return NULL;
  130. }
  131. else
  132. {
  133. return iter->second;
  134. }
  135. }
  136. //-----------------------------------------------------------------------------
  137. // setWeight()
  138. //-----------------------------------------------------------------------------
  139. void LLPose::setWeight(F32 weight)
  140. {
  141. joint_map_iterator iter;
  142. for(iter = mJointMap.begin(); 
  143. iter != mJointMap.end();
  144. ++iter)
  145. {
  146. iter->second->setWeight(weight);
  147. }
  148. mWeight = weight;
  149. }
  150. //-----------------------------------------------------------------------------
  151. // getWeight()
  152. //-----------------------------------------------------------------------------
  153. F32 LLPose::getWeight() const
  154. {
  155. return mWeight;
  156. }
  157. //-----------------------------------------------------------------------------
  158. // getNumJointStates()
  159. //-----------------------------------------------------------------------------
  160. S32 LLPose::getNumJointStates() const
  161. {
  162. return (S32)mJointMap.size();
  163. }
  164. //-----------------------------------------------------------------------------
  165. // LLJointStateBlender
  166. //-----------------------------------------------------------------------------
  167. LLJointStateBlender::LLJointStateBlender()
  168. {
  169. for(S32 i = 0; i < JSB_NUM_JOINT_STATES; i++)
  170. {
  171. mJointStates[i] = NULL;
  172. mPriorities[i] = S32_MIN;
  173. mAdditiveBlends[i] = FALSE;
  174. }
  175. }
  176. LLJointStateBlender::~LLJointStateBlender()
  177. {
  178. }
  179. //-----------------------------------------------------------------------------
  180. // addJointState()
  181. //-----------------------------------------------------------------------------
  182. BOOL LLJointStateBlender::addJointState(const LLPointer<LLJointState>& joint_state, S32 priority, BOOL additive_blend)
  183. {
  184. llassert(joint_state);
  185. if (!joint_state->getJoint())
  186. // this joint state doesn't point to an actual joint, so we don't care about applying it
  187. return FALSE;
  188. for(S32 i = 0; i < JSB_NUM_JOINT_STATES; i++)
  189. {
  190. if (mJointStates[i].isNull())
  191. {
  192. mJointStates[i] = joint_state;
  193. mPriorities[i] = priority;
  194. mAdditiveBlends[i] = additive_blend;
  195. return TRUE;
  196. else if (priority > mPriorities[i])
  197. {
  198. // we're at a higher priority than the current joint state in this slot
  199. // so shift everyone over
  200. // previous joint states (newer motions) with same priority should stay in place
  201. for (S32 j = JSB_NUM_JOINT_STATES - 1; j > i; j--)
  202. {
  203. mJointStates[j] = mJointStates[j - 1];
  204. mPriorities[j] = mPriorities[j - 1];
  205. mAdditiveBlends[j] = mAdditiveBlends[j - 1];
  206. }
  207. // now store ourselves in this slot
  208. mJointStates[i] = joint_state;
  209. mPriorities[i] = priority;
  210. mAdditiveBlends[i] = additive_blend;
  211. return TRUE;
  212. }
  213. }
  214. return FALSE;
  215. }
  216. //-----------------------------------------------------------------------------
  217. // blendJointStates()
  218. //-----------------------------------------------------------------------------
  219. void LLJointStateBlender::blendJointStates(BOOL apply_now)
  220. {
  221. // we need at least one joint to blend
  222. // if there is one, it will be in slot zero according to insertion logic
  223. // instead of resetting joint state to default, just leave it unchanged from last frame
  224. if (mJointStates[0].isNull())
  225. {
  226. return;
  227. }
  228. LLJoint* target_joint = apply_now ? mJointStates[0]->getJoint() : &mJointCache;
  229. const S32 POS_WEIGHT = 0;
  230. const S32 ROT_WEIGHT = 1;
  231. const S32 SCALE_WEIGHT = 2;
  232. F32 sum_weights[3];
  233. U32 sum_usage = 0;
  234. LLVector3 blended_pos = target_joint->getPosition();
  235. LLQuaternion blended_rot = target_joint->getRotation();
  236. LLVector3 blended_scale = target_joint->getScale();
  237. LLVector3 added_pos;
  238. LLQuaternion added_rot;
  239. LLVector3 added_scale;
  240. //S32 joint_state_index;
  241. sum_weights[POS_WEIGHT] = 0.f;
  242. sum_weights[ROT_WEIGHT] = 0.f;
  243. sum_weights[SCALE_WEIGHT] = 0.f;
  244. for(S32 joint_state_index = 0; 
  245. joint_state_index < JSB_NUM_JOINT_STATES && mJointStates[joint_state_index].notNull();
  246. joint_state_index++)
  247. {
  248. LLJointState* jsp = mJointStates[joint_state_index];
  249. U32 current_usage = jsp->getUsage();
  250. F32 current_weight = jsp->getWeight();
  251. if (current_weight == 0.f)
  252. {
  253. continue;
  254. }
  255. if (mAdditiveBlends[joint_state_index])
  256. {
  257. if(current_usage & LLJointState::POS)
  258. {
  259. F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[POS_WEIGHT]);
  260. // add in pos for this jointstate modulated by weight
  261. added_pos += jsp->getPosition() * (new_weight_sum - sum_weights[POS_WEIGHT]);
  262. }
  263. if(current_usage & LLJointState::SCALE)
  264. {
  265. F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[SCALE_WEIGHT]);
  266. // add in scale for this jointstate modulated by weight
  267. added_scale += jsp->getScale() * (new_weight_sum - sum_weights[SCALE_WEIGHT]);
  268. }
  269. if (current_usage & LLJointState::ROT)
  270. {
  271. F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[ROT_WEIGHT]);
  272. // add in rotation for this jointstate modulated by weight
  273. added_rot = nlerp((new_weight_sum - sum_weights[ROT_WEIGHT]), added_rot, jsp->getRotation()) * added_rot;
  274. }
  275. }
  276. else
  277. {
  278. // blend two jointstates together
  279. // blend position
  280. if(current_usage & LLJointState::POS)
  281. {
  282. if(sum_usage & LLJointState::POS)
  283. {
  284. F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[POS_WEIGHT]);
  285. // blend positions from both
  286. blended_pos = lerp(jsp->getPosition(), blended_pos, sum_weights[POS_WEIGHT] / new_weight_sum);
  287. sum_weights[POS_WEIGHT] = new_weight_sum;
  288. else
  289. {
  290. // copy position from current
  291. blended_pos = jsp->getPosition();
  292. sum_weights[POS_WEIGHT] = current_weight;
  293. }
  294. }
  295. // now do scale
  296. if(current_usage & LLJointState::SCALE)
  297. {
  298. if(sum_usage & LLJointState::SCALE)
  299. {
  300. F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[SCALE_WEIGHT]);
  301. // blend scales from both
  302. blended_scale = lerp(jsp->getScale(), blended_scale, sum_weights[SCALE_WEIGHT] / new_weight_sum);
  303. sum_weights[SCALE_WEIGHT] = new_weight_sum;
  304. else
  305. {
  306. // copy scale from current
  307. blended_scale = jsp->getScale();
  308. sum_weights[SCALE_WEIGHT] = current_weight;
  309. }
  310. }
  311. // rotation
  312. if (current_usage & LLJointState::ROT)
  313. {
  314. if(sum_usage & LLJointState::ROT)
  315. {
  316. F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[ROT_WEIGHT]);
  317. // blend rotations from both
  318. blended_rot = nlerp(sum_weights[ROT_WEIGHT] / new_weight_sum, jsp->getRotation(), blended_rot);
  319. sum_weights[ROT_WEIGHT] = new_weight_sum;
  320. else
  321. {
  322. // copy rotation from current
  323. blended_rot = jsp->getRotation();
  324. sum_weights[ROT_WEIGHT] = current_weight;
  325. }
  326. }
  327. // update resulting usage mask
  328. sum_usage = sum_usage | current_usage;
  329. }
  330. }
  331. if (!added_scale.isFinite())
  332. {
  333. added_scale.clearVec();
  334. }
  335. if (!blended_scale.isFinite())
  336. {
  337. blended_scale.setVec(1,1,1);
  338. }
  339. // apply transforms
  340. target_joint->setPosition(blended_pos + added_pos);
  341. target_joint->setScale(blended_scale + added_scale);
  342. target_joint->setRotation(added_rot * blended_rot);
  343. if (apply_now)
  344. {
  345. // now clear joint states
  346. for(S32 i = 0; i < JSB_NUM_JOINT_STATES; i++)
  347. {
  348. mJointStates[i] = NULL;
  349. }
  350. }
  351. }
  352. //-----------------------------------------------------------------------------
  353. // interpolate()
  354. //-----------------------------------------------------------------------------
  355. void LLJointStateBlender::interpolate(F32 u)
  356. {
  357. // only interpolate if we have a joint state
  358. if (!mJointStates[0])
  359. {
  360. return;
  361. }
  362. LLJoint* target_joint = mJointStates[0]->getJoint();
  363. if (!target_joint)
  364. {
  365. return;
  366. }
  367. target_joint->setPosition(lerp(target_joint->getPosition(), mJointCache.getPosition(), u));
  368. target_joint->setScale(lerp(target_joint->getScale(), mJointCache.getScale(), u));
  369. target_joint->setRotation(nlerp(u, target_joint->getRotation(), mJointCache.getRotation()));
  370. }
  371. //-----------------------------------------------------------------------------
  372. // clear()
  373. //-----------------------------------------------------------------------------
  374. void LLJointStateBlender::clear()
  375. {
  376. // now clear joint states
  377. for(S32 i = 0; i < JSB_NUM_JOINT_STATES; i++)
  378. {
  379. mJointStates[i] = NULL;
  380. }
  381. }
  382. //-----------------------------------------------------------------------------
  383. // resetCachedJoint()
  384. //-----------------------------------------------------------------------------
  385. void LLJointStateBlender::resetCachedJoint()
  386. {
  387. if (!mJointStates[0])
  388. {
  389. return;
  390. }
  391. LLJoint* source_joint = mJointStates[0]->getJoint();
  392. mJointCache.setPosition(source_joint->getPosition());
  393. mJointCache.setScale(source_joint->getScale());
  394. mJointCache.setRotation(source_joint->getRotation());
  395. }
  396. //-----------------------------------------------------------------------------
  397. // LLPoseBlender
  398. //-----------------------------------------------------------------------------
  399. LLPoseBlender::LLPoseBlender()
  400. : mNextPoseSlot(0)
  401. {
  402. }
  403. LLPoseBlender::~LLPoseBlender()
  404. {
  405. for_each(mJointStateBlenderPool.begin(), mJointStateBlenderPool.end(), DeletePairedPointer());
  406. }
  407. //-----------------------------------------------------------------------------
  408. // addMotion()
  409. //-----------------------------------------------------------------------------
  410. BOOL LLPoseBlender::addMotion(LLMotion* motion)
  411. {
  412. LLPose* pose = motion->getPose();
  413. for(LLJointState* jsp = pose->getFirstJointState(); jsp; jsp = pose->getNextJointState())
  414. {
  415. LLJoint *jointp = jsp->getJoint();
  416. LLJointStateBlender* joint_blender;
  417. if (mJointStateBlenderPool.find(jointp) == mJointStateBlenderPool.end())
  418. {
  419. // this is the first time we are animating this joint
  420. // so create new jointblender and add it to our pool
  421. joint_blender = new LLJointStateBlender();
  422. mJointStateBlenderPool[jointp] = joint_blender;
  423. }
  424. else
  425. {
  426. joint_blender = mJointStateBlenderPool[jointp];
  427. }
  428. if (jsp->getPriority() == LLJoint::USE_MOTION_PRIORITY)
  429. {
  430. joint_blender->addJointState(jsp, motion->getPriority(), motion->getBlendType() == LLMotion::ADDITIVE_BLEND);
  431. }
  432. else
  433. {
  434. joint_blender->addJointState(jsp, jsp->getPriority(), motion->getBlendType() == LLMotion::ADDITIVE_BLEND);
  435. }
  436. // add it to our list of active blenders
  437. if (std::find(mActiveBlenders.begin(), mActiveBlenders.end(), joint_blender) == mActiveBlenders.end())
  438. {
  439. mActiveBlenders.push_front(joint_blender);
  440. }
  441. }
  442. return TRUE;
  443. }
  444. //-----------------------------------------------------------------------------
  445. // blendAndApply()
  446. //-----------------------------------------------------------------------------
  447. void LLPoseBlender::blendAndApply()
  448. {
  449. for (blender_list_t::iterator iter = mActiveBlenders.begin();
  450.  iter != mActiveBlenders.end(); )
  451. {
  452. LLJointStateBlender* jsbp = *iter++;
  453. jsbp->blendJointStates();
  454. }
  455. // we're done now so there are no more active blenders for this frame
  456. mActiveBlenders.clear();
  457. }
  458. //-----------------------------------------------------------------------------
  459. // blendAndCache()
  460. //-----------------------------------------------------------------------------
  461. void LLPoseBlender::blendAndCache(BOOL reset_cached_joints)
  462. {
  463. for (blender_list_t::iterator iter = mActiveBlenders.begin();
  464.  iter != mActiveBlenders.end(); ++iter)
  465. {
  466. LLJointStateBlender* jsbp = *iter;
  467. if (reset_cached_joints)
  468. {
  469. jsbp->resetCachedJoint();
  470. }
  471. jsbp->blendJointStates(FALSE);
  472. }
  473. }
  474. //-----------------------------------------------------------------------------
  475. // interpolate()
  476. //-----------------------------------------------------------------------------
  477. void LLPoseBlender::interpolate(F32 u)
  478. {
  479. for (blender_list_t::iterator iter = mActiveBlenders.begin();
  480.  iter != mActiveBlenders.end(); ++iter)
  481. {
  482. LLJointStateBlender* jsbp = *iter;
  483. jsbp->interpolate(u);
  484. }
  485. }
  486. //-----------------------------------------------------------------------------
  487. // clearBlenders()
  488. //-----------------------------------------------------------------------------
  489. void LLPoseBlender::clearBlenders()
  490. {
  491. for (blender_list_t::iterator iter = mActiveBlenders.begin();
  492.  iter != mActiveBlenders.end(); ++iter)
  493. {
  494. LLJointStateBlender* jsbp = *iter;
  495. jsbp->clear();
  496. }
  497. mActiveBlenders.clear();
  498. }