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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llinterp.h
  3.  *
  4.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  5.  * 
  6.  * Copyright (c) 2001-2010, Linden Research, Inc.
  7.  * 
  8.  * Second Life Viewer Source Code
  9.  * The source code in this file ("Source Code") is provided by Linden Lab
  10.  * to you under the terms of the GNU General Public License, version 2.0
  11.  * ("GPL"), unless you have obtained a separate licensing agreement
  12.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  13.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  14.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  15.  * 
  16.  * There are special exceptions to the terms and conditions of the GPL as
  17.  * it is applied to this Source Code. View the full text of the exception
  18.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  19.  * online at
  20.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  21.  * 
  22.  * By copying, modifying or distributing this software, you acknowledge
  23.  * that you have read and understood your obligations described above,
  24.  * and agree to abide by those obligations.
  25.  * 
  26.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  27.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  28.  * COMPLETENESS OR PERFORMANCE.
  29.  * $/LicenseInfo$
  30.  */
  31. #ifndef LL_LLINTERP_H
  32. #define LL_LLINTERP_H
  33. #if defined(LL_WINDOWS)
  34. // macro definitions for common math constants (e.g. M_PI) are declared under the _USE_MATH_DEFINES
  35. // on Windows system.
  36. // So, let's define _USE_MATH_DEFINES before including math.h
  37. #define _USE_MATH_DEFINES
  38. #endif
  39. #include "math.h"
  40. // Class from which different types of interpolators can be derived
  41. class LLInterpVal
  42. {
  43. public:
  44. virtual ~LLInterpVal() {}
  45. virtual void interp(LLInterpVal &target, const F32 frac); // Linear interpolation for each type
  46. };
  47. template <typename Type>
  48. class LLInterp
  49. {
  50. public:
  51.         LLInterp();
  52. virtual ~LLInterp() {}
  53. virtual void start();
  54. void update(const F32 time);
  55. const Type &getCurVal() const;
  56. void setStartVal(const Type &start_val);
  57. const Type &getStartVal() const;
  58. void setEndVal(const Type &target_val);
  59. const Type &getEndVal() const;
  60. void setStartTime(const F32 time);
  61. F32 getStartTime() const;
  62. void setEndTime(const F32 time);
  63. F32 getEndTime() const;
  64. BOOL isActive() const;
  65. BOOL isDone() const;
  66. protected:
  67. F32 mStartTime;
  68. F32 mEndTime;
  69. F32 mDuration;
  70. BOOL mActive;
  71. BOOL mDone;
  72. Type mStartVal;
  73. Type mEndVal;
  74. F32 mCurTime;
  75. Type mCurVal;
  76. };
  77. template <typename Type>
  78. class LLInterpLinear : public LLInterp<Type>
  79. {
  80. public:
  81. /*virtual*/ void start();
  82. void update(const F32 time);
  83. F32 getCurFrac() const;
  84. protected:
  85. F32 mCurFrac;
  86. };
  87. template <typename Type>
  88. class LLInterpExp : public LLInterpLinear<Type>
  89. {
  90. public:
  91. void update(const F32 time);
  92. protected:
  93. };
  94. template <typename Type>
  95. class LLInterpAttractor : public LLInterp<Type>
  96. {
  97. public:
  98. LLInterpAttractor();
  99. /*virtual*/ void start();
  100. void setStartVel(const Type &vel);
  101. void setForce(const F32 force);
  102. void update(const F32 time);
  103. protected:
  104. F32 mForce;
  105. Type mStartVel;
  106. Type mVelocity;
  107. };
  108. template <typename Type>
  109. class LLInterpFunc : public LLInterp<Type>
  110. {
  111. public:
  112. LLInterpFunc();
  113. void update(const F32 time);
  114. void setFunc(Type (*)(const F32, void *data), void *data);
  115. protected:
  116. Type (*mFunc)(const F32 time, void *data);
  117. void *mData;
  118. };
  119. ///////////////////////////////////
  120. //
  121. // Implementation
  122. //
  123. //
  124. /////////////////////////////////
  125. //
  126. // LLInterp base class implementation
  127. //
  128. template <typename Type>
  129. LLInterp<Type>::LLInterp()
  130. : mStartVal(Type()), mEndVal(Type()), mCurVal(Type())
  131. {
  132. mStartTime = 0.f;
  133. mEndTime = 1.f;
  134. mDuration = 1.f;
  135. mCurTime = 0.f;
  136. mDone = FALSE;
  137. mActive = FALSE;
  138. }
  139. template <class Type>
  140. void LLInterp<Type>::setStartVal(const Type &start_val)
  141. {
  142. mStartVal = start_val;
  143. }
  144. template <class Type>
  145. void LLInterp<Type>::start()
  146. {
  147. mCurVal = mStartVal;
  148. mCurTime = mStartTime;
  149. mDone = FALSE;
  150. mActive = FALSE;
  151. }
  152. template <class Type>
  153. const Type &LLInterp<Type>::getStartVal() const
  154. {
  155. return mStartVal;
  156. }
  157. template <class Type>
  158. void LLInterp<Type>::setEndVal(const Type &end_val)
  159. {
  160. mEndVal = end_val;
  161. }
  162. template <class Type>
  163. const Type &LLInterp<Type>::getEndVal() const
  164. {
  165. return mEndVal;
  166. }
  167. template <class Type>
  168. const Type &LLInterp<Type>::getCurVal() const
  169. {
  170. return mCurVal;
  171. }
  172. template <class Type>
  173. void LLInterp<Type>::setStartTime(const F32 start_time)
  174. {
  175. mStartTime = start_time;
  176. mDuration = mEndTime - mStartTime;
  177. }
  178. template <class Type>
  179. F32 LLInterp<Type>::getStartTime() const
  180. {
  181. return mStartTime;
  182. }
  183. template <class Type>
  184. void LLInterp<Type>::setEndTime(const F32 end_time)
  185. {
  186. mEndTime = end_time;
  187. mDuration = mEndTime - mStartTime;
  188. }
  189. template <class Type>
  190. F32 LLInterp<Type>::getEndTime() const
  191. {
  192. return mEndTime;
  193. }
  194. template <class Type>
  195. BOOL LLInterp<Type>::isDone() const
  196. {
  197. return mDone;
  198. }
  199. template <class Type>
  200. BOOL LLInterp<Type>::isActive() const
  201. {
  202. return mActive;
  203. }
  204. //////////////////////////////
  205. //
  206. // LLInterpLinear derived class implementation.
  207. //
  208. template <typename Type>
  209. void LLInterpLinear<Type>::start()
  210. {
  211. LLInterp<Type>::start();
  212. mCurFrac = 0.f;
  213. }
  214. template <typename Type>
  215. void LLInterpLinear<Type>::update(const F32 time)
  216. {
  217. F32 target_frac = (time - this->mStartTime) / this->mDuration;
  218. F32 dfrac = target_frac - this->mCurFrac;
  219. if (target_frac >= 0.f)
  220. {
  221. this->mActive = TRUE;
  222. }
  223. if (target_frac > 1.f)
  224. {
  225. this->mCurVal = this->mEndVal;
  226. this->mCurFrac = 1.f;
  227. this->mCurTime = time;
  228. this->mDone = TRUE;
  229. return;
  230. }
  231. target_frac = llmin(1.f, target_frac);
  232. target_frac = llmax(0.f, target_frac);
  233. if (dfrac >= 0.f)
  234. {
  235. F32 total_frac = 1.f - this->mCurFrac;
  236. F32 inc_frac = dfrac / total_frac;
  237. this->mCurVal = inc_frac * this->mEndVal + (1.f - inc_frac) * this->mCurVal;
  238. this->mCurTime = time;
  239. }
  240. else
  241. {
  242. F32 total_frac = this->mCurFrac - 1.f;
  243. F32 inc_frac = dfrac / total_frac;
  244. this->mCurVal = inc_frac * this->mStartVal + (1.f - inc_frac) * this->mCurVal;
  245. this->mCurTime = time;
  246. }
  247. mCurFrac = target_frac;
  248. }
  249. template <class Type>
  250. F32 LLInterpLinear<Type>::getCurFrac() const
  251. {
  252. return mCurFrac;
  253. }
  254. //////////////////////////////
  255. //
  256. // LLInterpAttractor derived class implementation.
  257. //
  258. template <class Type>
  259. LLInterpAttractor<Type>::LLInterpAttractor() : LLInterp<Type>()
  260. {
  261. mForce = 0.1f;
  262. mVelocity *= 0.f;
  263. mStartVel *= 0.f;
  264. }
  265. template <class Type>
  266. void LLInterpAttractor<Type>::start()
  267. {
  268. LLInterp<Type>::start();
  269. mVelocity = mStartVel;
  270. }
  271. template <class Type>
  272. void LLInterpAttractor<Type>::setStartVel(const Type &vel)
  273. {
  274. mStartVel = vel;
  275. }
  276. template <class Type>
  277. void LLInterpAttractor<Type>::setForce(const F32 force)
  278. {
  279. mForce = force;
  280. }
  281. template <class Type>
  282. void LLInterpAttractor<Type>::update(const F32 time)
  283. {
  284. if (time > this->mStartTime)
  285. {
  286. this->mActive = TRUE;
  287. }
  288. else
  289. {
  290. return;
  291. }
  292. if (time > this->mEndTime)
  293. {
  294. this->mDone = TRUE;
  295. return;
  296. }
  297. F32 dt = time - this->mCurTime;
  298. Type dist_val = this->mEndVal - this->mCurVal;
  299. Type dv = 0.5*dt*dt*this->mForce*dist_val;
  300. this->mVelocity += dv;
  301. this->mCurVal += this->mVelocity * dt;
  302. this->mCurTime = time;
  303. }
  304. //////////////////////////////
  305. //
  306. // LLInterpFucn derived class implementation.
  307. //
  308. template <class Type>
  309. LLInterpFunc<Type>::LLInterpFunc() : LLInterp<Type>()
  310. {
  311. mFunc = NULL;
  312. mData = NULL;
  313. }
  314. template <class Type>
  315. void LLInterpFunc<Type>::setFunc(Type (*func)(const F32, void *data), void *data)
  316. {
  317. mFunc = func;
  318. mData = data;
  319. }
  320. template <class Type>
  321. void LLInterpFunc<Type>::update(const F32 time)
  322. {
  323. if (time > this->mStartTime)
  324. {
  325. this->mActive = TRUE;
  326. }
  327. else
  328. {
  329. return;
  330. }
  331. if (time > this->mEndTime)
  332. {
  333. this->mDone = TRUE;
  334. return;
  335. }
  336. this->mCurVal = (*mFunc)(time - this->mStartTime, mData);
  337. this->mCurTime = time;
  338. }
  339. //////////////////////////////
  340. //
  341. // LLInterpExp derived class implementation.
  342. //
  343. template <class Type>
  344. void LLInterpExp<Type>::update(const F32 time)
  345. {
  346. F32 target_frac = (time - this->mStartTime) / this->mDuration;
  347. if (target_frac >= 0.f)
  348. {
  349. this->mActive = TRUE;
  350. }
  351. if (target_frac > 1.f)
  352. {
  353. this->mCurVal = this->mEndVal;
  354. this->mCurFrac = 1.f;
  355. this->mCurTime = time;
  356. this->mDone = TRUE;
  357. return;
  358. }
  359. this->mCurFrac = 1.f - (F32)(exp(-2.f*target_frac));
  360. this->mCurVal = this->mStartVal + this->mCurFrac * (this->mEndVal - this->mStartVal);
  361. this->mCurTime = time;
  362. }
  363. #endif // LL_LLINTERP_H