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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llkeyframemotion.h
  3.  * @brief Implementation of LLKeframeMotion 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. #ifndef LL_LLKEYFRAMEMOTION_H
  33. #define LL_LLKEYFRAMEMOTION_H
  34. //-----------------------------------------------------------------------------
  35. // Header files
  36. //-----------------------------------------------------------------------------
  37. #include <string>
  38. #include "llassetstorage.h"
  39. #include "llbboxlocal.h"
  40. #include "llhandmotion.h"
  41. #include "lljointstate.h"
  42. #include "llmotion.h"
  43. #include "llquaternion.h"
  44. #include "v3dmath.h"
  45. #include "v3math.h"
  46. #include "llbvhconsts.h"
  47. class LLKeyframeDataCache;
  48. class LLVFS;
  49. class LLDataPacker;
  50. #define MIN_REQUIRED_PIXEL_AREA_KEYFRAME (40.f)
  51. #define MAX_CHAIN_LENGTH (4)
  52. const S32 KEYFRAME_MOTION_VERSION = 1;
  53. const S32 KEYFRAME_MOTION_SUBVERSION = 0;
  54. //-----------------------------------------------------------------------------
  55. // class LLKeyframeMotion
  56. //-----------------------------------------------------------------------------
  57. class LLKeyframeMotion :
  58. public LLMotion
  59. {
  60. friend class LLKeyframeDataCache;
  61. public:
  62. // Constructor
  63. LLKeyframeMotion(const LLUUID &id);
  64. // Destructor
  65. virtual ~LLKeyframeMotion();
  66. private:
  67. // private helper functions to wrap some asserts
  68. LLPointer<LLJointState>& getJointState(U32 index);
  69. LLJoint* getJoint(U32 index);
  70. public:
  71. //-------------------------------------------------------------------------
  72. // functions to support MotionController and MotionRegistry
  73. //-------------------------------------------------------------------------
  74. // static constructor
  75. // all subclasses must implement such a function and register it
  76. static LLMotion *create(const LLUUID& id);
  77. public:
  78. //-------------------------------------------------------------------------
  79. // animation callbacks to be implemented by subclasses
  80. //-------------------------------------------------------------------------
  81. // motions must specify whether or not they loop
  82. virtual BOOL getLoop() { 
  83. if (mJointMotionList) return mJointMotionList->mLoop; 
  84. else return FALSE;
  85. }
  86. // motions must report their total duration
  87. virtual F32 getDuration() { 
  88. if (mJointMotionList) return mJointMotionList->mDuration; 
  89. else return 0.f;
  90. }
  91. // motions must report their "ease in" duration
  92. virtual F32 getEaseInDuration() { 
  93. if (mJointMotionList) return mJointMotionList->mEaseInDuration; 
  94. else return 0.f;
  95. }
  96. // motions must report their "ease out" duration.
  97. virtual F32 getEaseOutDuration() { 
  98. if (mJointMotionList) return mJointMotionList->mEaseOutDuration; 
  99. else return 0.f;
  100. }
  101. // motions must report their priority
  102. virtual LLJoint::JointPriority getPriority() { 
  103. if (mJointMotionList) return mJointMotionList->mBasePriority; 
  104. else return LLJoint::LOW_PRIORITY;
  105. }
  106. virtual LLMotionBlendType getBlendType() { return NORMAL_BLEND; }
  107. // called to determine when a motion should be activated/deactivated based on avatar pixel coverage
  108. virtual F32 getMinPixelArea() { return MIN_REQUIRED_PIXEL_AREA_KEYFRAME; }
  109. // run-time (post constructor) initialization,
  110. // called after parameters have been set
  111. // must return true to indicate success and be available for activation
  112. virtual LLMotionInitStatus onInitialize(LLCharacter *character);
  113. // called when a motion is activated
  114. // must return TRUE to indicate success, or else
  115. // it will be deactivated
  116. virtual BOOL onActivate();
  117. // called per time step
  118. // must return TRUE while it is active, and
  119. // must return FALSE when the motion is completed.
  120. virtual BOOL onUpdate(F32 time, U8* joint_mask);
  121. // called when a motion is deactivated
  122. virtual void onDeactivate();
  123. virtual void setStopTime(F32 time);
  124. static void setVFS(LLVFS* vfs) { sVFS = vfs; }
  125. static void onLoadComplete(LLVFS *vfs,
  126.    const LLUUID& asset_uuid,
  127.    LLAssetType::EType type,
  128.    void* user_data, S32 status, LLExtStat ext_status);
  129. public:
  130. U32 getFileSize();
  131. BOOL serialize(LLDataPacker& dp) const;
  132. BOOL deserialize(LLDataPacker& dp);
  133. BOOL isLoaded() { return mJointMotionList != NULL; }
  134. // setters for modifying a keyframe animation
  135. void setLoop(BOOL loop);
  136. F32 getLoopIn() {
  137. return (mJointMotionList) ? mJointMotionList->mLoopInPoint : 0.f;
  138. }
  139. F32 getLoopOut() {
  140. return (mJointMotionList) ? mJointMotionList->mLoopOutPoint : 0.f;
  141. }
  142. void setLoopIn(F32 in_point);
  143. void setLoopOut(F32 out_point);
  144. void setHandPose(LLHandMotion::eHandPose pose) {
  145. if (mJointMotionList) mJointMotionList->mHandPose = pose;
  146. }
  147. LLHandMotion::eHandPose getHandPose() { 
  148. return (mJointMotionList) ? mJointMotionList->mHandPose : LLHandMotion::HAND_POSE_RELAXED;
  149. }
  150. void setPriority(S32 priority);
  151. void setEmote(const LLUUID& emote_id);
  152. void setEaseIn(F32 ease_in);
  153. void setEaseOut(F32 ease_in);
  154. F32 getLastUpdateTime() { return mLastLoopedTime; }
  155. const LLBBoxLocal& getPelvisBBox();
  156. static void flushKeyframeCache();
  157. protected:
  158. //-------------------------------------------------------------------------
  159. // JointConstraintSharedData
  160. //-------------------------------------------------------------------------
  161. class JointConstraintSharedData
  162. {
  163. public:
  164. JointConstraintSharedData() :
  165. mChainLength(0),
  166. mEaseInStartTime(0.f), 
  167. mEaseInStopTime(0.f),
  168. mEaseOutStartTime(0.f),
  169. mEaseOutStopTime(0.f), 
  170. mUseTargetOffset(FALSE),
  171. mConstraintType(CONSTRAINT_TYPE_POINT),
  172. mConstraintTargetType(CONSTRAINT_TARGET_TYPE_BODY),
  173. mSourceConstraintVolume(0),
  174. mTargetConstraintVolume(0),
  175. mJointStateIndices(NULL)
  176. { };
  177. ~JointConstraintSharedData() { delete [] mJointStateIndices; }
  178. S32 mSourceConstraintVolume;
  179. LLVector3 mSourceConstraintOffset;
  180. S32 mTargetConstraintVolume;
  181. LLVector3 mTargetConstraintOffset;
  182. LLVector3 mTargetConstraintDir;
  183. S32 mChainLength;
  184. S32* mJointStateIndices;
  185. F32 mEaseInStartTime;
  186. F32 mEaseInStopTime;
  187. F32 mEaseOutStartTime;
  188. F32 mEaseOutStopTime;
  189. BOOL mUseTargetOffset;
  190. EConstraintType mConstraintType;
  191. EConstraintTargetType mConstraintTargetType;
  192. };
  193. //-----------------------------------------------------------------------------
  194. // JointConstraint()
  195. //-----------------------------------------------------------------------------
  196. class JointConstraint
  197. {
  198. public:
  199. JointConstraint(JointConstraintSharedData* shared_data);
  200. ~JointConstraint();
  201. JointConstraintSharedData* mSharedData;
  202. F32 mWeight;
  203. F32 mTotalLength;
  204. LLVector3 mPositions[MAX_CHAIN_LENGTH];
  205. F32 mJointLengths[MAX_CHAIN_LENGTH];
  206. F32 mJointLengthFractions[MAX_CHAIN_LENGTH];
  207. BOOL mActive;
  208. LLVector3d mGroundPos;
  209. LLVector3 mGroundNorm;
  210. LLJoint* mSourceVolume;
  211. LLJoint* mTargetVolume;
  212. F32 mFixupDistanceRMS;
  213. };
  214. void applyKeyframes(F32 time);
  215. void applyConstraints(F32 time, U8* joint_mask);
  216. void activateConstraint(JointConstraint* constraintp);
  217. void initializeConstraint(JointConstraint* constraint);
  218. void deactivateConstraint(JointConstraint *constraintp);
  219. void applyConstraint(JointConstraint* constraintp, F32 time, U8* joint_mask);
  220. BOOL setupPose();
  221. public:
  222. enum AssetStatus { ASSET_LOADED, ASSET_FETCHED, ASSET_NEEDS_FETCH, ASSET_FETCH_FAILED, ASSET_UNDEFINED };
  223. enum InterpolationType { IT_STEP, IT_LINEAR, IT_SPLINE };
  224. //-------------------------------------------------------------------------
  225. // ScaleKey
  226. //-------------------------------------------------------------------------
  227. class ScaleKey
  228. {
  229. public:
  230. ScaleKey() { mTime = 0.0f; }
  231. ScaleKey(F32 time, const LLVector3 &scale) { mTime = time; mScale = scale; }
  232. F32 mTime;
  233. LLVector3 mScale;
  234. };
  235. //-------------------------------------------------------------------------
  236. // RotationKey
  237. //-------------------------------------------------------------------------
  238. class RotationKey
  239. {
  240. public:
  241. RotationKey() { mTime = 0.0f; }
  242. RotationKey(F32 time, const LLQuaternion &rotation) { mTime = time; mRotation = rotation; }
  243. F32 mTime;
  244. LLQuaternion mRotation;
  245. };
  246. //-------------------------------------------------------------------------
  247. // PositionKey
  248. //-------------------------------------------------------------------------
  249. class PositionKey
  250. {
  251. public:
  252. PositionKey() { mTime = 0.0f; }
  253. PositionKey(F32 time, const LLVector3 &position) { mTime = time; mPosition = position; }
  254. F32 mTime;
  255. LLVector3 mPosition;
  256. };
  257. //-------------------------------------------------------------------------
  258. // ScaleCurve
  259. //-------------------------------------------------------------------------
  260. class ScaleCurve
  261. {
  262. public:
  263. ScaleCurve();
  264. ~ScaleCurve();
  265. LLVector3 getValue(F32 time, F32 duration);
  266. LLVector3 interp(F32 u, ScaleKey& before, ScaleKey& after);
  267. InterpolationType mInterpolationType;
  268. S32 mNumKeys;
  269. typedef std::map<F32, ScaleKey> key_map_t;
  270. key_map_t  mKeys;
  271. ScaleKey mLoopInKey;
  272. ScaleKey mLoopOutKey;
  273. };
  274. //-------------------------------------------------------------------------
  275. // RotationCurve
  276. //-------------------------------------------------------------------------
  277. class RotationCurve
  278. {
  279. public:
  280. RotationCurve();
  281. ~RotationCurve();
  282. LLQuaternion getValue(F32 time, F32 duration);
  283. LLQuaternion interp(F32 u, RotationKey& before, RotationKey& after);
  284. InterpolationType mInterpolationType;
  285. S32 mNumKeys;
  286. typedef std::map<F32, RotationKey> key_map_t;
  287. key_map_t mKeys;
  288. RotationKey mLoopInKey;
  289. RotationKey mLoopOutKey;
  290. };
  291. //-------------------------------------------------------------------------
  292. // PositionCurve
  293. //-------------------------------------------------------------------------
  294. class PositionCurve
  295. {
  296. public:
  297. PositionCurve();
  298. ~PositionCurve();
  299. LLVector3 getValue(F32 time, F32 duration);
  300. LLVector3 interp(F32 u, PositionKey& before, PositionKey& after);
  301. InterpolationType mInterpolationType;
  302. S32 mNumKeys;
  303. typedef std::map<F32, PositionKey> key_map_t;
  304. key_map_t mKeys;
  305. PositionKey mLoopInKey;
  306. PositionKey mLoopOutKey;
  307. };
  308. //-------------------------------------------------------------------------
  309. // JointMotion
  310. //-------------------------------------------------------------------------
  311. class JointMotion
  312. {
  313. public:
  314. PositionCurve mPositionCurve;
  315. RotationCurve mRotationCurve;
  316. ScaleCurve mScaleCurve;
  317. std::string mJointName;
  318. U32 mUsage;
  319. LLJoint::JointPriority mPriority;
  320. void update(LLJointState* joint_state, F32 time, F32 duration);
  321. };
  322. //-------------------------------------------------------------------------
  323. // JointMotionList
  324. //-------------------------------------------------------------------------
  325. class JointMotionList
  326. {
  327. public:
  328. std::vector<JointMotion*> mJointMotionArray;
  329. F32 mDuration;
  330. BOOL mLoop;
  331. F32 mLoopInPoint;
  332. F32 mLoopOutPoint;
  333. F32 mEaseInDuration;
  334. F32 mEaseOutDuration;
  335. LLJoint::JointPriority mBasePriority;
  336. LLHandMotion::eHandPose mHandPose;
  337. LLJoint::JointPriority  mMaxPriority;
  338. typedef std::list<JointConstraintSharedData*> constraint_list_t;
  339. constraint_list_t mConstraints;
  340. LLBBoxLocal mPelvisBBox;
  341. // mEmoteName is a facial motion, but it's necessary to appear here so that it's cached.
  342. // TODO: LLKeyframeDataCache::getKeyframeData should probably return a class containing 
  343. // JointMotionList and mEmoteName, see LLKeyframeMotion::onInitialize.
  344. std::string mEmoteName; 
  345. public:
  346. JointMotionList();
  347. ~JointMotionList();
  348. U32 dumpDiagInfo();
  349. JointMotion* getJointMotion(U32 index) const { llassert(index < mJointMotionArray.size()); return mJointMotionArray[index]; }
  350. U32 getNumJointMotions() const { return mJointMotionArray.size(); }
  351. };
  352. protected:
  353. static LLVFS* sVFS;
  354. //-------------------------------------------------------------------------
  355. // Member Data
  356. //-------------------------------------------------------------------------
  357. JointMotionList* mJointMotionList;
  358. std::vector<LLPointer<LLJointState> > mJointStates;
  359. LLJoint* mPelvisp;
  360. LLCharacter* mCharacter;
  361. typedef std::list<JointConstraint*> constraint_list_t;
  362. constraint_list_t mConstraints;
  363. U32 mLastSkeletonSerialNum;
  364. F32 mLastUpdateTime;
  365. F32 mLastLoopedTime;
  366. AssetStatus mAssetStatus;
  367. };
  368. class LLKeyframeDataCache
  369. {
  370. public:
  371. // *FIX: implement this as an actual singleton member of LLKeyframeMotion
  372. LLKeyframeDataCache(){};
  373. ~LLKeyframeDataCache();
  374. typedef std::map<LLUUID, class LLKeyframeMotion::JointMotionList*> keyframe_data_map_t; 
  375. static keyframe_data_map_t sKeyframeDataMap;
  376. static void addKeyframeData(const LLUUID& id, LLKeyframeMotion::JointMotionList*);
  377. static LLKeyframeMotion::JointMotionList* getKeyframeData(const LLUUID& id);
  378. static void removeKeyframeData(const LLUUID& id);
  379. //print out diagnostic info
  380. static void dumpDiagInfo();
  381. static void clear();
  382. };
  383. #endif // LL_LLKEYFRAMEMOTION_H