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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llfollowcam.h
  3.  * @author Jeffrey Ventrella
  4.  * @brief LLFollowCam class definition
  5.  *
  6.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2005-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  33. //--------------------------------------------------------------------
  34. // FollowCam
  35. //
  36. // The FollowCam controls three dynamic variables which determine 
  37. // a camera orientation and position for a "loose" third-person view
  38. // (orientation being derived from a combination of focus and up 
  39. // vector). It is good for fast-moving vehicles that change 
  40. // acceleration a lot, but it can also be general-purpose, like for 
  41. // avatar navigation. It has a handful of parameters allowing it to 
  42. // be tweaked to assume different styles of tracking objects.
  43. //
  44. //--------------------------------------------------------------------
  45. #ifndef LL_FOLLOWCAM_H
  46. #define LL_FOLLOWCAM_H
  47. #include "llcoordframe.h"
  48. #include "indra_constants.h"
  49. #include "llmath.h"
  50. #include "lltimer.h"
  51. #include "llquaternion.h"
  52. #include "llcriticaldamp.h"
  53. #include <map>
  54. #include <vector>
  55. class LLFollowCamParams
  56. {
  57. public:
  58. LLFollowCamParams();
  59. virtual ~LLFollowCamParams();
  60. //--------------------------------------
  61. // setty setty set set
  62. //--------------------------------------
  63. virtual void setPositionLag ( F32 );
  64. virtual void setFocusLag ( F32 );
  65. virtual void setFocusThreshold ( F32 );
  66. virtual void setPositionThreshold ( F32 );
  67. virtual void setDistance ( F32 );
  68. virtual void setPitch ( F32 );
  69. virtual void setFocusOffset ( const LLVector3& );
  70. virtual void setBehindnessAngle ( F32 );
  71. virtual void setBehindnessLag ( F32 );
  72. virtual void setPosition ( const LLVector3& );
  73. virtual void setFocus ( const LLVector3& );
  74. virtual void setPositionLocked ( bool );
  75. virtual void setFocusLocked ( bool );
  76. //--------------------------------------
  77. // getty getty get get
  78. //--------------------------------------
  79. virtual F32 getPositionLag() const;
  80. virtual F32 getFocusLag() const;
  81. virtual F32 getPositionThreshold() const;
  82. virtual F32 getFocusThreshold() const;
  83. virtual F32 getDistance() const;
  84. virtual F32 getPitch() const;
  85. virtual LLVector3 getFocusOffset() const;
  86. virtual F32 getBehindnessAngle() const;
  87. virtual F32 getBehindnessLag() const;
  88. virtual LLVector3 getPosition() const;
  89. virtual LLVector3 getFocus() const;
  90. virtual bool getFocusLocked() const;
  91. virtual bool getPositionLocked() const;
  92. virtual bool getUseFocus() const { return mUseFocus; }
  93. virtual bool getUsePosition() const { return mUsePosition; }
  94. protected:
  95. F32 mPositionLag;
  96. F32 mFocusLag;
  97. F32 mFocusThreshold;
  98. F32 mPositionThreshold;
  99. F32 mDistance;
  100. F32 mPitch;
  101. LLVector3 mFocusOffset;
  102. F32 mBehindnessMaxAngle;
  103. F32 mBehindnessLag;
  104. F32 mMaxCameraDistantFromSubject;
  105. bool mPositionLocked;
  106. bool mFocusLocked;
  107. bool mUsePosition; // specific camera point specified by script
  108. bool mUseFocus; // specific focus point specified by script
  109. LLVector3 mPosition; // where the camera is (in world-space)
  110. LLVector3 mFocus; // what the camera is aimed at (in world-space)
  111. };
  112. class LLFollowCam : public LLFollowCamParams
  113. {
  114. public:
  115. //--------------------
  116. // Contructor
  117. //--------------------
  118. LLFollowCam();
  119. //--------------------
  120. // Destructor
  121. //--------------------
  122. virtual ~LLFollowCam();
  123. //---------------------------------------------------------------------------------------
  124. // The following methods must be called every time step. However, if you know for 
  125. // sure that your  subject matter (what the camera is looking at) is not moving, 
  126. // then you can get away with not calling "update" But keep in mind that "update" 
  127. // may still be needed after the subject matter has stopped moving because the 
  128. // camera may still need to animate itself catching up to its ideal resting place. 
  129. //---------------------------------------------------------------------------------------
  130. void setSubjectPositionAndRotation ( const LLVector3 p, const LLQuaternion r );
  131. void update();
  132. // initialize from another instance of llfollowcamparams
  133. void copyParams(LLFollowCamParams& params);
  134. //-----------------------------------------------------------------------------------
  135. // this is how to bang the followCam into a specific configuration. Keep in mind 
  136. // that it will immediately try to adjust these values according to its attributes. 
  137. //-----------------------------------------------------------------------------------
  138. void reset( const LLVector3 position, const LLVector3 focus, const LLVector3 upVector );
  139. void setMaxCameraDistantFromSubject ( F32 m ); // this should be determined by llAgent
  140. bool isZoomedToMinimumDistance();
  141. LLVector3 getUpVector();
  142. void zoom( S32 );
  143. // overrides for setters and getters
  144. virtual void setPitch( F32 );
  145. virtual void setDistance( F32 );
  146. virtual void setPosition(const LLVector3& pos);
  147. virtual void setFocus(const LLVector3& focus);
  148. virtual void setPositionLocked ( bool );
  149. virtual void setFocusLocked ( bool );
  150. LLVector3 getSimulatedPosition() const;
  151. LLVector3 getSimulatedFocus() const;
  152. //------------------------------------------
  153. // protected members of FollowCam
  154. //------------------------------------------
  155. protected:
  156. F32 mPitchCos; // derived from mPitch
  157. F32 mPitchSin; // derived from mPitch
  158. LLGlobalVec mSimulatedPositionGlobal; // where the camera is (global coordinates), simulated
  159. LLGlobalVec mSimulatedFocusGlobal; // what the camera is aimed at (global coordinates), simulated
  160. F32 mSimulatedDistance;
  161. //---------------------
  162. // dynamic variables
  163. //---------------------
  164. bool mZoomedToMinimumDistance;
  165. LLFrameTimer mTimer;
  166. LLVector3 mSubjectPosition; // this is the position of what I'm looking at
  167. LLQuaternion mSubjectRotation; // this is the rotation of what I'm looking at
  168. LLVector3 mUpVector; // the camera's up vector in world-space (determines roll)
  169. LLVector3 mRelativeFocus;
  170. LLVector3 mRelativePos;
  171. bool mPitchSineAndCosineNeedToBeUpdated;
  172. //------------------------------------------
  173. // protected methods of FollowCam
  174. //------------------------------------------
  175. protected:
  176. void calculatePitchSineAndCosine();
  177. BOOL updateBehindnessConstraint(LLVector3 focus, LLVector3& cam_position);
  178. };// end of FollowCam class
  179. class LLFollowCamMgr
  180. {
  181. public:
  182. static void cleanupClass ( );
  183. static void setPositionLag ( const LLUUID& source, F32 lag);
  184. static void setFocusLag ( const LLUUID& source, F32 lag);
  185. static void setFocusThreshold ( const LLUUID& source, F32 threshold);
  186. static void setPositionThreshold ( const LLUUID& source, F32 threshold);
  187. static void setDistance ( const LLUUID& source, F32 distance);
  188. static void setPitch ( const LLUUID& source, F32 pitch);
  189. static void setFocusOffset ( const LLUUID& source, const LLVector3& offset);
  190. static void setBehindnessAngle ( const LLUUID& source, F32 angle);
  191. static void setBehindnessLag ( const LLUUID& source, F32 lag);
  192. static void setPosition ( const LLUUID& source, const LLVector3 position);
  193. static void setFocus ( const LLUUID& source, const LLVector3 focus);
  194. static void setPositionLocked ( const LLUUID& source, bool locked);
  195. static void setFocusLocked ( const LLUUID& source, bool locked );
  196. static void setCameraActive ( const LLUUID& source, bool active );
  197. static LLFollowCamParams* getActiveFollowCamParams();
  198. static LLFollowCamParams* getParamsForID(const LLUUID& source);
  199. static void removeFollowCamParams(const LLUUID& source);
  200. static bool isScriptedCameraSource(const LLUUID& source);
  201. static void dump();
  202. protected:
  203. typedef std::map<LLUUID, LLFollowCamParams*> param_map_t;
  204. static param_map_t sParamMap;
  205. typedef std::vector<LLFollowCamParams*> param_stack_t;
  206. static param_stack_t sParamStack;
  207. };
  208. #endif //LL_FOLLOWCAM_H