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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llmotion.h
  3.  * @brief Implementation of LLMotion 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_LLMOTION_H
  33. #define LL_LLMOTION_H
  34. //-----------------------------------------------------------------------------
  35. // Header files
  36. //-----------------------------------------------------------------------------
  37. #include <string>
  38. #include "llerror.h"
  39. #include "llpose.h"
  40. #include "lluuid.h"
  41. class LLCharacter;
  42. //-----------------------------------------------------------------------------
  43. // class LLMotion
  44. //-----------------------------------------------------------------------------
  45. class LLMotion
  46. {
  47. friend class LLMotionController;
  48. public:
  49. enum LLMotionBlendType
  50. {
  51. NORMAL_BLEND,
  52. ADDITIVE_BLEND
  53. };
  54. enum LLMotionInitStatus
  55. {
  56. STATUS_FAILURE,
  57. STATUS_SUCCESS,
  58. STATUS_HOLD
  59. };
  60. // Constructor
  61. LLMotion(const LLUUID &id);
  62. // Destructor
  63. virtual ~LLMotion();
  64. public:
  65. //-------------------------------------------------------------------------
  66. // functions to support MotionController and MotionRegistry
  67. //-------------------------------------------------------------------------
  68. // get the name of this instance
  69. const std::string &getName() const { return mName; }
  70. // set the name of this instance
  71. void setName(const std::string &name) { mName = name; }
  72. const LLUUID& getID() const { return mID; }
  73. // returns the pose associated with the current state of this motion
  74. virtual LLPose* getPose() { return &mPose;}
  75. void fadeOut();
  76. void fadeIn();
  77. F32 getFadeWeight() const { return mFadeWeight; }
  78. F32 getStopTime() const { return mStopTimestamp; }
  79. virtual void setStopTime(F32 time);
  80. BOOL isStopped() const { return mStopped; }
  81. void setStopped(BOOL stopped) { mStopped = stopped; }
  82. BOOL isBlending();
  83. // Activation functions.
  84. // It is OK for other classes to activate a motion,
  85. // but only the controller can deactivate it.
  86. // Thus, if mActive == TRUE, the motion *may* be on the controllers active list,
  87. // but if mActive == FALSE, the motion is gauranteed not to be on the active list.
  88. protected:
  89. // Used by LLMotionController only
  90. void deactivate();
  91. BOOL isActive() { return mActive; }
  92. public:
  93. void activate(F32 time);
  94. public:
  95. //-------------------------------------------------------------------------
  96. // animation callbacks to be implemented by subclasses
  97. //-------------------------------------------------------------------------
  98. // motions must specify whether or not they loop
  99. virtual BOOL getLoop() = 0;
  100. // motions must report their total duration
  101. virtual F32 getDuration() = 0;
  102. // motions must report their "ease in" duration
  103. virtual F32 getEaseInDuration() = 0;
  104. // motions must report their "ease out" duration.
  105. virtual F32 getEaseOutDuration() = 0;
  106. // motions must report their priority level
  107. virtual LLJoint::JointPriority getPriority() = 0;
  108. // motions must report their blend type
  109. virtual LLMotionBlendType getBlendType() = 0;
  110. // called to determine when a motion should be activated/deactivated based on avatar pixel coverage
  111. virtual F32 getMinPixelArea() = 0;
  112. // run-time (post constructor) initialization,
  113. // called after parameters have been set
  114. // must return true to indicate success and be available for activation
  115. virtual LLMotionInitStatus onInitialize(LLCharacter *character) = 0;
  116. // called per time step
  117. // must return TRUE while it is active, and
  118. // must return FALSE when the motion is completed.
  119. virtual BOOL onUpdate(F32 activeTime, U8* joint_mask) = 0;
  120. // called when a motion is deactivated
  121. virtual void onDeactivate() = 0;
  122. // can we crossfade this motion with a new instance when restarted?
  123. // should ultimately always be TRUE, but lack of emote blending, etc
  124. // requires this
  125. virtual BOOL canDeprecate();
  126. // optional callback routine called when animation deactivated.
  127. void setDeactivateCallback( void (*cb)(void *), void* userdata );
  128. protected:
  129. // called when a motion is activated
  130. // must return TRUE to indicate success, or else
  131. // it will be deactivated
  132. virtual BOOL onActivate() = 0;
  133. void addJointState(const LLPointer<LLJointState>& jointState);
  134. protected:
  135. LLPose mPose;
  136. BOOL mStopped; // motion has been stopped;
  137. BOOL mActive; // motion is on active list (can be stopped or not stopped)
  138. //-------------------------------------------------------------------------
  139. // these are set implicitly by the motion controller and
  140. // may be referenced (read only) in the above handlers.
  141. //-------------------------------------------------------------------------
  142. std::string mName; // instance name assigned by motion controller
  143. LLUUID mID;
  144. F32 mActivationTimestamp; // time when motion was activated
  145. F32 mStopTimestamp; // time when motion was told to stop
  146. F32 mSendStopTimestamp; // time when simulator should be told to stop this motion
  147. F32 mResidualWeight; // blend weight at beginning of stop motion phase
  148. F32 mFadeWeight; // for fading in and out based on LOD
  149. U8 mJointSignature[3][LL_CHARACTER_MAX_JOINTS]; // signature of which joints are animated at what priority
  150. void (*mDeactivateCallback)(void* data);
  151. void* mDeactivateCallbackUserData;
  152. };
  153. //-----------------------------------------------------------------------------
  154. // LLTestMotion
  155. //-----------------------------------------------------------------------------
  156. class LLTestMotion : public LLMotion
  157. {
  158. public:
  159. LLTestMotion(const LLUUID &id) : LLMotion(id){}
  160. ~LLTestMotion() {}
  161. static LLMotion *create(const LLUUID& id) { return new LLTestMotion(id); }
  162. BOOL getLoop() { return FALSE; }
  163. F32 getDuration() { return 0.0f; }
  164. F32 getEaseInDuration() { return 0.0f; }
  165. F32 getEaseOutDuration() { return 0.0f; }
  166. LLJoint::JointPriority getPriority() { return LLJoint::HIGH_PRIORITY; }
  167. LLMotionBlendType getBlendType() { return NORMAL_BLEND; }
  168. F32 getMinPixelArea() { return 0.f; }
  169. LLMotionInitStatus onInitialize(LLCharacter*) { llinfos << "LLTestMotion::onInitialize()" << llendl; return STATUS_SUCCESS; }
  170. BOOL onActivate() { llinfos << "LLTestMotion::onActivate()" << llendl; return TRUE; }
  171. BOOL onUpdate(F32 time, U8* joint_mask) { llinfos << "LLTestMotion::onUpdate(" << time << ")" << llendl; return TRUE; }
  172. void onDeactivate() { llinfos << "LLTestMotion::onDeactivate()" << llendl; }
  173. };
  174. //-----------------------------------------------------------------------------
  175. // LLNullMotion
  176. //-----------------------------------------------------------------------------
  177. class LLNullMotion : public LLMotion
  178. {
  179. public:
  180. LLNullMotion(const LLUUID &id) : LLMotion(id) {}
  181. ~LLNullMotion() {}
  182. static LLMotion *create(const LLUUID &id) { return new LLNullMotion(id); }
  183. // motions must specify whether or not they loop
  184. /*virtual*/ BOOL getLoop() { return TRUE; }
  185. // motions must report their total duration
  186. /*virtual*/ F32 getDuration() { return 1.f; }
  187. // motions must report their "ease in" duration
  188. /*virtual*/ F32 getEaseInDuration() { return 0.f; }
  189. // motions must report their "ease out" duration.
  190. /*virtual*/ F32 getEaseOutDuration() { return 0.f; }
  191. // motions must report their priority level
  192. /*virtual*/ LLJoint::JointPriority getPriority() { return LLJoint::HIGH_PRIORITY; }
  193. // motions must report their blend type
  194. /*virtual*/ LLMotionBlendType getBlendType() { return NORMAL_BLEND; }
  195. // called to determine when a motion should be activated/deactivated based on avatar pixel coverage
  196. /*virtual*/ F32 getMinPixelArea() { return 0.f; }
  197. // run-time (post constructor) initialization,
  198. // called after parameters have been set
  199. // must return true to indicate success and be available for activation
  200. /*virtual*/ LLMotionInitStatus onInitialize(LLCharacter *character) { return STATUS_SUCCESS; }
  201. // called when a motion is activated
  202. // must return TRUE to indicate success, or else
  203. // it will be deactivated
  204. /*virtual*/ BOOL onActivate() { return TRUE; }
  205. // called per time step
  206. // must return TRUE while it is active, and
  207. // must return FALSE when the motion is completed.
  208. /*virtual*/ BOOL onUpdate(F32 activeTime, U8* joint_mask) { return TRUE; }
  209. // called when a motion is deactivated
  210. /*virtual*/ void onDeactivate() {}
  211. };
  212. #endif // LL_LLMOTION_H