开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llquaternion_test.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：25k
源码类别：

游戏引擎

开发平台：

C++ Builder

llquaternion_test.cpp：源码内容
  1. /** 
  2.  * @file llquaternion_test.cpp
  3.  * @author Adroit
  4.  * @date 2007-03
  5.  * @brief Test cases of llquaternion.h
  6.  *
  7.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2007-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  35. #include "linden_common.h"
  36. #include "../test/lltut.h"
  38. #include "../llquaternion.h"
  39. #include "../v4math.h"
  40. #include "../v3math.h"
  41. #include "../v3dmath.h"
  42. #include "../m4math.h"
  43. #include "../m3math.h"
  45. namespace tut
  46. {
  47. struct llquat_test
  48. {
  49. };
  50. typedef test_group<llquat_test> llquat_test_t;
  51. typedef llquat_test_t::object llquat_test_object_t;
  52. tut::llquat_test_t tut_llquat_test("llquat");
  54. //test case for LLQuaternion::LLQuaternion(void) fn.
  55. template<> template<>
  56. void llquat_test_object_t::test<1>()
  57. {
  58. LLQuaternion llquat;
  59. ensure("LLQuaternion::LLQuaternion() failed", 0.f == llquat.mQ[0] &&
  60.   0.f == llquat.mQ[1] &&
  61.   0.f == llquat.mQ[2] &&
  62. 1.f == llquat.mQ[3]);
  63. }
  65. //test case for explicit LLQuaternion(const LLMatrix4 &mat) fn.
  66. template<> template<>
  67. void llquat_test_object_t::test<2>()
  68. {
  69. LLMatrix4 llmat;
  70. LLVector4 vector1(2.0f, 1.0f, 3.0f, 6.0f);
  71. LLVector4 vector2(5.0f, 6.0f, 0.0f, 1.0f);
  72. LLVector4 vector3(2.0f, 1.0f, 2.0f, 9.0f);
  73. LLVector4 vector4(3.0f, 8.0f, 1.0f, 5.0f);
  75. llmat.initRows(vector1, vector2, vector3, vector4);
  76. ensure("explicit LLQuaternion(const LLMatrix4 &mat) failed", 2.0f == llmat.mMatrix[0][0] &&
  77.   1.0f == llmat.mMatrix[0][1] &&
  78. 3.0f == llmat.mMatrix[0][2] &&
  79. 6.0f == llmat.mMatrix[0][3] &&
  80. 5.0f == llmat.mMatrix[1][0] &&
  81. 6.0f == llmat.mMatrix[1][1] &&
  82. 0.0f == llmat.mMatrix[1][2] &&
  83. 1.0f == llmat.mMatrix[1][3] &&
  84. 2.0f == llmat.mMatrix[2][0] &&
  85. 1.0f == llmat.mMatrix[2][1] &&
  86. 2.0f == llmat.mMatrix[2][2] &&
  87. 9.0f == llmat.mMatrix[2][3] &&
  88. 3.0f == llmat.mMatrix[3][0] &&
  89. 8.0f == llmat.mMatrix[3][1] &&
  90. 1.0f == llmat.mMatrix[3][2] &&
  91. 5.0f == llmat.mMatrix[3][3]);
  92. }
  94. template<> template<>
  95. void llquat_test_object_t::test<3>()
  96. {
  97. LLMatrix3 llmat;
  99. LLVector3 vect1(3.4028234660000000f , 234.56f, 4234.442234f);
  100. LLVector3 vect2(741.434f, 23.00034f, 6567.223423f);
  101. LLVector3 vect3(566.003034f, 12.98705f, 234.764423f);
  102. llmat.setRows(vect1, vect2, vect3);
  104. ensure("LLMatrix3::setRows fn failed.", 3.4028234660000000f == llmat.mMatrix[0][0] &&
  105. 234.56f == llmat.mMatrix[0][1] &&
  106. 4234.442234f == llmat.mMatrix[0][2] &&
  107. 741.434f == llmat.mMatrix[1][0] &&
  108. 23.00034f == llmat.mMatrix[1][1] &&
  109. 6567.223423f == llmat.mMatrix[1][2] &&
  110. 566.003034f == llmat.mMatrix[2][0] &&
  111. 12.98705f == llmat.mMatrix[2][1] &&
  112. 234.764423f == llmat.mMatrix[2][2]);
  113. }
  115. //test case for LLQuaternion(F32 x, F32 y, F32 z, F32 w), setQuatInit() and normQuat() fns.
  116. template<> template<>
  117. void llquat_test_object_t::test<4>()
  118. {
  119. F32 x_val = 3.0f;
  120. F32 y_val = 2.0f;
  121. F32 z_val = 6.0f;
  122. F32 w_val = 1.0f;
  124. LLQuaternion res_quat;
  125. res_quat.setQuatInit(x_val, y_val, z_val, w_val);
  126. res_quat.normQuat();
  128. ensure("LLQuaternion::normQuat() fn failed", 
  129. is_approx_equal(0.42426407f, res_quat.mQ[0]) &&
  130. is_approx_equal(0.28284273f, res_quat.mQ[1]) &&
  131. is_approx_equal(0.84852815f, res_quat.mQ[2]) &&
  132. is_approx_equal(0.14142136f, res_quat.mQ[3]));
  134. x_val = 0.0f;
  135. y_val = 0.0f;
  136. z_val = 0.0f;
  137. w_val = 0.0f;
  139. res_quat.setQuatInit(x_val, y_val, z_val, w_val);
  140. res_quat.normQuat();
  142. ensure("LLQuaternion::normQuat() fn. failed.", 
  143. is_approx_equal(0.0f, res_quat.mQ[0]) &&
  144. is_approx_equal(0.0f, res_quat.mQ[1]) &&
  145. is_approx_equal(0.0f, res_quat.mQ[2]) &&
  146. is_approx_equal(1.0f, res_quat.mQ[3]));
  149. ensure("LLQuaternion::normQuat() fn. failed.", 
  150. is_approx_equal(0.0f, res_quat.mQ[0]) &&
  151. is_approx_equal(0.0f, res_quat.mQ[1]) &&
  152. is_approx_equal(0.0f, res_quat.mQ[2]) &&
  153. is_approx_equal(1.0f, res_quat.mQ[3]));
  154. }
  156. //test case for conjQuat() and transQuat() fns.
  157. template<> template<>
  158. void llquat_test_object_t::test<5>()
  159. {
  160. F32 x_val = 3.0f;
  161. F32 y_val = 2.0f;
  162. F32 z_val = 6.0f;
  163. F32 w_val = 1.0f;
  165. LLQuaternion res_quat;
  166. LLQuaternion result, result1;
  167. result1 = result = res_quat.setQuatInit(x_val, y_val, z_val, w_val);
  169. result.conjQuat();
  170. result1.transQuat();
  172. ensure("LLQuaternion::conjQuat and LLQuaternion::transQuat failed ", 
  173. is_approx_equal(result1.mQ[0], result.mQ[0]) &&
  174. is_approx_equal(result1.mQ[1], result.mQ[1]) &&
  175. is_approx_equal(result1.mQ[2], result.mQ[2]));
  177. }
  179. //test case for dot(const LLQuaternion &a, const LLQuaternion &b) fn.
  180. template<> template<>
  181. void llquat_test_object_t::test<6>()
  182. {
  183. LLQuaternion quat1(3.0f, 2.0f, 6.0f, 0.0f), quat2(1.0f, 1.0f, 1.0f, 1.0f);
  184. ensure("1. The two values are different", llround(12.000000f, 2) == llround(dot(quat1, quat2), 2));
  186. LLQuaternion quat0(3.0f, 9.334f, 34.5f, 23.0f), quat(34.5f, 23.23f, 2.0f, 45.5f);
  187. ensure("2. The two values are different", llround(1435.828807f, 2) == llround(dot(quat0, quat), 2));
  188. }
  190. //test case for LLQuaternion &LLQuaternion::constrain(F32 radians) fn.
  191. template<> template<>
  192. void llquat_test_object_t::test<7>()
  193. {
  194. F32 radian = 60.0f;
  195. LLQuaternion quat(3.0f, 2.0f, 6.0f, 0.0f);
  196. LLQuaternion quat1;
  197. quat1 = quat.constrain(radian);
  198. ensure("1. LLQuaternion::constrain(F32 radians) failed", 
  199. is_approx_equal_fraction(-0.423442f, quat1.mQ[0], 8) &&
  200. is_approx_equal_fraction(-0.282295f, quat1.mQ[1], 8) &&
  201. is_approx_equal_fraction(-0.846884f, quat1.mQ[2], 8) &&
  202. is_approx_equal_fraction(0.154251f, quat1.mQ[3], 8));
  205. radian = 30.0f;
  206. LLQuaternion quat0(37.50f, 12.0f, 86.023f, 40.32f);
  207. quat1 = quat0.constrain(radian);
  209. ensure("2. LLQuaternion::constrain(F32 radians) failed", 
  210. is_approx_equal_fraction(37.500000f, quat1.mQ[0], 8) &&
  211. is_approx_equal_fraction(12.0000f, quat1.mQ[1], 8) &&
  212. is_approx_equal_fraction(86.0230f, quat1.mQ[2], 8) &&
  213. is_approx_equal_fraction(40.320000f, quat1.mQ[3], 8));
  214. }
  216. template<> template<>
  217. void llquat_test_object_t::test<8>()
  218. {
  219. F32 value1 = 15.0f;
  220. LLQuaternion quat1(1.0f, 2.0f, 4.0f, 1.0f);
  221. LLQuaternion quat2(4.0f, 3.0f, 6.5f, 9.7f);
  222. LLQuaternion res_lerp, res_slerp, res_nlerp;
  224. //test case for lerp(F32 t, const LLQuaternion &q) fn. 
  225. res_lerp = lerp(value1, quat1);
  226. ensure("1. LLQuaternion lerp(F32 t, const LLQuaternion &q) failed", 
  227. is_approx_equal_fraction(0.181355f, res_lerp.mQ[0], 16) &&
  228. is_approx_equal_fraction(0.362711f, res_lerp.mQ[1], 16) &&
  229. is_approx_equal_fraction(0.725423f, res_lerp.mQ[2], 16) &&
  230. is_approx_equal_fraction(0.556158f, res_lerp.mQ[3], 16));
  232. //test case for lerp(F32 t, const LLQuaternion &p, const LLQuaternion &q) fn.
  233. res_lerp = lerp(value1, quat1, quat2);
  234. ensure("2. LLQuaternion lerp(F32 t, const LLQuaternion &p, const LLQuaternion &q) failed",
  235. is_approx_equal_fraction(0.314306f, res_lerp.mQ[0], 16) &&
  236. is_approx_equal_fraction(0.116156f, res_lerp.mQ[1], 16) &&
  237. is_approx_equal_fraction(0.283559f, res_lerp.mQ[2], 16) &&
  238. is_approx_equal_fraction(0.898506f, res_lerp.mQ[3], 16));
  240. //test case for slerp( F32 u, const LLQuaternion &a, const LLQuaternion &b ) fn.
  241. res_slerp = slerp(value1, quat1, quat2);
  242. ensure("3. LLQuaternion slerp( F32 u, const LLQuaternion &a, const LLQuaternion &b) failed", 
  243. is_approx_equal_fraction(46.000f, res_slerp.mQ[0], 16) &&
  244. is_approx_equal_fraction(17.00f, res_slerp.mQ[1], 16) &&
  245. is_approx_equal_fraction(41.5f, res_slerp.mQ[2], 16) &&
  246. is_approx_equal_fraction(131.5f, res_slerp.mQ[3], 16));
  248. //test case for nlerp(F32 t, const LLQuaternion &a, const LLQuaternion &b) fn.
  249. res_nlerp = nlerp(value1, quat1, quat2);
  250. ensure("4. LLQuaternion nlerp(F32 t, const LLQuaternion &a, const LLQuaternion &b) failed",  
  251. is_approx_equal_fraction(0.314306f, res_nlerp.mQ[0], 16) &&
  252. is_approx_equal_fraction(0.116157f, res_nlerp.mQ[1], 16) &&
  253. is_approx_equal_fraction(0.283559f, res_nlerp.mQ[2], 16) &&
  254. is_approx_equal_fraction(0.898506f, res_nlerp.mQ[3], 16));
  256. //test case for nlerp(F32 t, const LLQuaternion &q) fn.
  257. res_slerp = slerp(value1, quat1);
  258. ensure("5. LLQuaternion slerp(F32 t, const LLQuaternion &q) failed", 
  259. is_approx_equal_fraction(1.0f, res_slerp.mQ[0], 16) &&
  260. is_approx_equal_fraction(2.0f, res_slerp.mQ[1], 16) &&
  261. is_approx_equal_fraction(4.0000f, res_slerp.mQ[2], 16) &&
  262. is_approx_equal_fraction(1.000f, res_slerp.mQ[3], 16));
  264. LLQuaternion quat3(2.0f, 1.0f, 5.5f, 10.5f);
  265. LLQuaternion res_nlerp1;
  266. value1 = 100.0f;
  267. res_nlerp1 = nlerp(value1, quat3);
  268. ensure("6. LLQuaternion nlerp(F32 t, const LLQuaternion &q)  failed", 
  269. is_approx_equal_fraction(0.268245f, res_nlerp1.mQ[0], 16) && is_approx_equal_fraction(0.134122f, res_nlerp1.mQ[1], 2) &&
  270. is_approx_equal_fraction(0.737673f, res_nlerp1.mQ[2], 16) &&
  271. is_approx_equal_fraction(0.604892f, res_nlerp1.mQ[3], 16));
  273. //test case for lerp(F32 t, const LLQuaternion &q) fn. 
  274. res_lerp = lerp(value1, quat2);
  275. ensure("7. LLQuaternion lerp(F32 t, const LLQuaternion &q) failed", 
  276. is_approx_equal_fraction(0.404867f, res_lerp.mQ[0], 16) &&
  277. is_approx_equal_fraction(0.303650f, res_lerp.mQ[1], 16) &&
  278. is_approx_equal_fraction(0.657909f, res_lerp.mQ[2], 16) &&
  279. is_approx_equal_fraction(0.557704f, res_lerp.mQ[3], 16));
  281. }
  283. template<> template<>
  284. void llquat_test_object_t::test<9>()
  285. {
  286. //test case for LLQuaternion operator*(const LLQuaternion &a, const LLQuaternion &b) fn
  287. LLQuaternion quat1(1.0f, 2.5f, 3.5f, 5.5f);
  288. LLQuaternion quat2(4.0f, 3.0f, 5.0f, 1.0f);
  289. LLQuaternion result = quat1 *  quat2;
  290. ensure("1. LLQuaternion Operator* failed", (21.0f == result.mQ[0]) &&
  291. (10.0f == result.mQ[1]) &&
  292. (38.0f == result.mQ[2]) && 
  293. (-23.5f == result.mQ[3]));
  295. LLQuaternion quat3(2341.340f, 2352.345f, 233.25f, 7645.5f);
  296. LLQuaternion quat4(674.067f, 893.0897f, 578.0f, 231.0f);
  297. result = quat3 * quat4;
  298. ensure("2. LLQuaternion Operator* failed", (4543086.5f == result.mQ[0]) &&
  299. (8567578.0f == result.mQ[1]) &&
  300. (3967591.25f == result.mQ[2]) &&
  301. is_approx_equal(-2047783.25f, result.mQ[3]));
  303. //inline LLQuaternion operator+(const LLQuaternion &a, const LLQuaternion &b)fn.
  304. result = quat1 + quat2;
  305. ensure("3. LLQuaternion operator+ failed", (5.0f == result.mQ[0]) &&
  306. (5.5f == result.mQ[1]) &&
  307. (8.5f == result.mQ[2]) &&
  308. (6.5f == result.mQ[3]));
  310. result = quat3 + quat4;
  311. ensure(
  312. "4. LLQuaternion operator+ failed",
  313. is_approx_equal(3015.407227f, result.mQ[0]) &&
  314. is_approx_equal(3245.434570f, result.mQ[1]) &&
  315. (811.25f == result.mQ[2]) &&
  316. (7876.5f == result.mQ[3]));
  318. //inline LLQuaternion operator-(const LLQuaternion &a, const LLQuaternion &b) fn
  319. result = quat1 - quat2;
  320. ensure(
  321. "5. LLQuaternion operator-(const LLQuaternion &a, const LLQuaternion &b) failed", 
  322. (-3.0f == result.mQ[0]) &&
  323. (-0.5f == result.mQ[1]) &&
  324. (-1.5f == result.mQ[2]) &&
  325. (4.5f == result.mQ[3]));
  327. result = quat3 - quat4;
  328. ensure(
  329. "6. LLQuaternion operator-(const LLQuaternion &a, const LLQuaternion &b) failed", 
  330. is_approx_equal(1667.273071f, result.mQ[0]) &&
  331. is_approx_equal(1459.255249f, result.mQ[1]) &&
  332. (-344.75f == result.mQ[2]) &&
  333. (7414.50f == result.mQ[3]));
  334. }
  336. //test case for LLVector4 operator*(const LLVector4 &a, const LLQuaternion &rot) fn.
  337. template<> template<>
  338. void llquat_test_object_t::test<10>()
  339. {
  340. LLVector4 vect(12.0f, 5.0f, 60.0f, 75.1f);
  341. LLQuaternion quat(2323.034f, 23.5f, 673.23f, 57667.5f);
  342. LLVector4 result = vect * quat;
  343. ensure(
  344. "1. LLVector4 operator*(const LLVector4 &a, const LLQuaternion &rot) failed", 
  345. is_approx_equal(39928406016.0f, result.mV[0]) &&
  346. // gcc on x86 actually gives us more precision than we were expecting, verified with -ffloat-store - we forgive this
  347. (1457802240.0f >= result.mV[1]) && // gcc+x86+linux
  348. (1457800960.0f <= result.mV[1]) && // elsewhere
  349. is_approx_equal(200580612096.0f, result.mV[2]) &&
  350. (75.099998f == result.mV[3]));
  352. LLVector4 vect1(22.0f, 45.0f, 40.0f, 78.1f);
  353. LLQuaternion quat1(2.034f, 45.5f, 37.23f, 7.5f);
  354. result = vect1 * quat1;
  355. ensure(
  356. "2. LLVector4 operator*(const LLVector4 &a, const LLQuaternion &rot) failed", 
  357. is_approx_equal(-58153.5390f, result.mV[0]) &&
  358. (183787.8125f == result.mV[1]) &&
  359. (116864.164063f == result.mV[2]) &&
  360. (78.099998f == result.mV[3]));
  361. }
  363. //test case for LLVector3 operator*(const LLVector3 &a, const LLQuaternion &rot) fn.
  364. template<> template<>
  365. void llquat_test_object_t::test<11>()
  366. {
  367. LLVector3 vect(12.0f, 5.0f, 60.0f);
  368. LLQuaternion quat(23.5f, 6.5f, 3.23f, 56.5f);
  369. LLVector3 result = vect * quat;
  370. ensure(
  371. "1. LLVector3 operator*(const LLVector3 &a, const LLQuaternion &rot) failed", 
  372. is_approx_equal(97182.953125f,result.mV[0]) &&
  373. is_approx_equal(-135405.640625f, result.mV[1]) &&
  374. is_approx_equal(162986.140f, result.mV[2]));
  376. LLVector3 vect1(5.0f, 40.0f, 78.1f);
  377. LLQuaternion quat1(2.034f, 45.5f, 37.23f, 7.5f);
  378. result = vect1 * quat1;
  379. ensure(
  380. "2. LLVector3 operator*(const LLVector3 &a, const LLQuaternion &rot) failed", 
  381. is_approx_equal(33217.703f, result.mV[0]) &&
  382. is_approx_equal(295383.8125f, result.mV[1]) &&
  383. is_approx_equal(84718.140f, result.mV[2]));
  384. }
  386. //test case for LLVector3d operator*(const LLVector3d &a, const LLQuaternion &rot) fn.
  387. template<> template<>
  388. void llquat_test_object_t::test<12>()
  389. {
  390. LLVector3d vect(-2.0f, 5.0f, -6.0f);
  391. LLQuaternion quat(-3.5f, 4.5f, 3.5f, 6.5f);
  392. LLVector3d result = vect * quat;
  393. ensure(
  394. "1. LLVector3d operator*(const LLVector3d &a, const LLQuaternion &rot) failed ", 
  395. (-633.0f == result.mdV[0]) &&
  396. (-300.0f == result.mdV[1]) &&
  397. (-36.0f == result.mdV[2]));
  399. LLVector3d vect1(5.0f, -4.5f, 8.21f);
  400. LLQuaternion quat1(2.0f, 4.5f, -7.2f, 9.5f);
  401. result = vect1 * quat1;
  402. ensure(
  403. "2. LLVector3d operator*(const LLVector3d &a, const LLQuaternion &rot) failed", 
  404. is_approx_equal_fraction(-120.29f, (F32) result.mdV[0], 8) &&
  405. is_approx_equal_fraction(-1683.958f, (F32) result.mdV[1], 8) &&
  406. is_approx_equal_fraction(516.56f, (F32) result.mdV[2], 8));
  408. LLVector3d vect2(2.0f, 3.5f, 1.1f);
  409. LLQuaternion quat2(1.0f, 4.0f, 2.0f, 5.0f);
  410. result = vect2 * quat2;
  411. ensure(
  412. "3. LLVector3d operator*(const LLVector3d &a, const LLQuaternion &rot) failed", 
  413. is_approx_equal_fraction(18.400001f, (F32) result.mdV[0], 8) &&
  414. is_approx_equal_fraction(188.6f, (F32) result.mdV[1], 8) &&
  415. is_approx_equal_fraction(32.20f, (F32) result.mdV[2], 8));
  416. }
  418. //test case for inline LLQuaternion operator-(const LLQuaternion &a) fn.
  419. template<> template<>
  420. void llquat_test_object_t::test<13>()
  421. {
  422. LLQuaternion quat(23.5f, 34.5f, 16723.4f, 324.7f);
  423. LLQuaternion result = -quat;
  424. ensure(
  425. "1. LLQuaternion operator-(const LLQuaternion &a) failed", 
  426. (-23.5f == result.mQ[0]) &&
  427. (-34.5f == result.mQ[1]) &&
  428. (-16723.4f == result.mQ[2]) &&
  429. (-324.7f == result.mQ[3]));
  431. LLQuaternion quat1(-3.5f, -34.5f, -16.4f, -154.7f);
  432. result = -quat1;
  433. ensure(
  434. "2. LLQuaternion operator-(const LLQuaternion &a) failed.", 
  435. (3.5f == result.mQ[0]) &&
  436. (34.5f == result.mQ[1]) &&
  437. (16.4f == result.mQ[2]) &&
  438. (154.7f == result.mQ[3]));
  439. }
  441. //test case for inline LLQuaternion operator*(F32 a, const LLQuaternion &q) and
  442. //inline LLQuaternion operator*(F32 a, const LLQuaternion &q) fns.
  443. template<> template<>
  444. void llquat_test_object_t::test<14>()
  445. {
  446. LLQuaternion quat_value(9.0f, 8.0f, 7.0f, 6.0f);
  447. F32 a =3.5f;
  448. LLQuaternion result = a * quat_value;
  449. LLQuaternion result1 = quat_value * a;
  451. ensure(
  452. "1. LLQuaternion operator* failed",
  453. (result.mQ[0] == result1.mQ[0]) &&
  454. (result.mQ[1] == result1.mQ[1]) &&
  455. (result.mQ[2] == result1.mQ[2]) &&
  456. (result.mQ[3] == result1.mQ[3]));
  459. LLQuaternion quat_val(9454.0f, 43568.3450f, 456343247.0343f, 2346.03434f);
  460. a =-3324.3445f;
  461. result = a * quat_val;
  462. result1 = quat_val * a;
  464. ensure(
  465. "2. LLQuaternion operator* failed",
  466. (result.mQ[0] == result1.mQ[0]) &&
  467. (result.mQ[1] == result1.mQ[1]) &&
  468. (result.mQ[2] == result1.mQ[2]) &&
  469. (result.mQ[3] == result1.mQ[3]));
  470. }
  472. template<> template<>
  473. void llquat_test_object_t::test<15>()
  474. {
  475. // test cases for inline LLQuaternion operator~(const LLQuaternion &a)
  476. LLQuaternion quat_val(2323.634f, -43535.4f, 3455.88f, -32232.45f);
  477. LLQuaternion result = ~quat_val;
  478. ensure(
  479. "1. LLQuaternion operator~(const LLQuaternion &a) failed ", 
  480. (-2323.634f == result.mQ[0]) &&
  481. (43535.4f == result.mQ[1]) &&
  482. (-3455.88f == result.mQ[2]) &&
  483. (-32232.45f == result.mQ[3]));
  485. //test case for inline bool LLQuaternion::operator==(const LLQuaternion &b) const
  486. LLQuaternion quat_val1(2323.634f, -43535.4f, 3455.88f, -32232.45f);
  487. LLQuaternion quat_val2(2323.634f, -43535.4f, 3455.88f, -32232.45f);
  488. ensure(
  489. "2. LLQuaternion::operator==(const LLQuaternion &b) failed",
  490. quat_val1 == quat_val2);
  491. }
  493. template<> template<>
  494. void llquat_test_object_t::test<16>()
  495. {
  496. //test case for inline bool LLQuaternion::operator!=(const LLQuaternion &b) const
  497. LLQuaternion quat_val1(2323.634f, -43535.4f, 3455.88f, -32232.45f);
  498. LLQuaternion quat_val2(0, -43535.4f, 3455.88f, -32232.45f);
  499. ensure("LLQuaternion::operator!=(const LLQuaternion &b) failed", quat_val1 != quat_val2);
  500. }
  502. template<> template<>
  503. void llquat_test_object_t::test<17>()
  504. {
  505. //test case for LLQuaternion mayaQ(F32 xRot, F32 yRot, F32 zRot, LLQuaternion::Order order)
  506. F32 x = 2.0f;
  507. F32 y = 1.0f;
  508. F32 z = 3.0f;
  510. LLQuaternion result = mayaQ(x, y, z, LLQuaternion::XYZ);
  511. ensure(
  512. "1. LLQuaternion mayaQ(F32 xRot, F32 yRot, F32 zRot, LLQuaternion::Order order) failed for XYZ",
  513. is_approx_equal_fraction(0.0172174f, result.mQ[0], 16) &&
  514. is_approx_equal_fraction(0.009179f, result.mQ[1], 16) &&
  515. is_approx_equal_fraction(0.026020f, result.mQ[2], 16) &&
  516. is_approx_equal_fraction(0.999471f, result.mQ[3], 16));
  518. LLQuaternion result1 = mayaQ(x, y, z, LLQuaternion::YZX);
  519. ensure(
  520. "2. LLQuaternion mayaQ(F32 xRot, F32 yRot, F32 zRot, LLQuaternion::Order order) failed for XYZ",
  521. is_approx_equal_fraction(0.017217f, result1.mQ[0], 16) &&
  522. is_approx_equal_fraction(0.008265f, result1.mQ[1], 16) &&
  523. is_approx_equal_fraction(0.026324f, result1.mQ[2], 16) &&
  524. is_approx_equal_fraction(0.999471f, result1.mQ[3], 16));
  526. LLQuaternion result2 = mayaQ(x, y, z, LLQuaternion::ZXY);
  527. ensure(
  528. "3. LLQuaternion mayaQ(F32 xRot, F32 yRot, F32 zRot, LLQuaternion::Order order) failed for ZXY", 
  529. is_approx_equal_fraction(0.017674f, result2.mQ[0], 16) &&
  530. is_approx_equal_fraction(0.008265f, result2.mQ[1], 16) &&
  531. is_approx_equal_fraction(0.026020f, result2.mQ[2], 16) &&
  532. is_approx_equal_fraction(0.999471f, result2.mQ[3], 16));
  534. LLQuaternion result3 = mayaQ(x, y, z, LLQuaternion::XZY);
  535. ensure(
  536. "4. TLLQuaternion mayaQ(F32 xRot, F32 yRot, F32 zRot, LLQuaternion::Order order) failed for XZY", 
  537. is_approx_equal_fraction(0.017674f, result3.mQ[0], 16) &&
  538. is_approx_equal_fraction(0.009179f, result3.mQ[1], 16) &&
  539. is_approx_equal_fraction(0.026020f, result3.mQ[2], 16) &&
  540. is_approx_equal_fraction(0.999463f, result3.mQ[3], 16));
  542. LLQuaternion result4 = mayaQ(x, y, z, LLQuaternion::YXZ);
  543. ensure(
  544. "5. LLQuaternion mayaQ(F32 xRot, F32 yRot, F32 zRot, LLQuaternion::Order order) failed for YXZ", 
  545. is_approx_equal_fraction(0.017217f, result4.mQ[0], 16) &&
  546. is_approx_equal_fraction(0.009179f, result4.mQ[1], 16) &&
  547. is_approx_equal_fraction(0.026324f, result4.mQ[2], 16) &&
  548. is_approx_equal_fraction(0.999463f, result4.mQ[3], 16));
  550. LLQuaternion result5 = mayaQ(x, y, z, LLQuaternion::ZYX);
  551. ensure(
  552. "6. LLQuaternion mayaQ(F32 xRot, F32 yRot, F32 zRot, LLQuaternion::Order order) failed for ZYX", 
  553. is_approx_equal_fraction(0.017674f, result5.mQ[0], 16) &&
  554. is_approx_equal_fraction(0.008265f, result5.mQ[1], 16) &&
  555. is_approx_equal_fraction(0.026324f, result5.mQ[2], 16) &&
  556. is_approx_equal_fraction(0.999463f, result5.mQ[3], 16));
  557. }
  559. template<> template<>
  560. void llquat_test_object_t::test<18>()
  561. {
  562. // test case for friend std::ostream& operator<<(std::ostream &s, const LLQuaternion &a) fn
  563. LLQuaternion a(1.0f, 1.0f, 1.0f, 1.0f); 
  564. std::ostringstream result_value;
  565. result_value << a;
  566. ensure_equals("1. Operator << failed", result_value.str(), "{ 1, 1, 1, 1 }");
  568. LLQuaternion b(-31.034f, 231.2340f, 3451.344320f, -341.0f); 
  569. std::ostringstream result_value1;
  570. result_value1 << b;
  571. ensure_equals("2. Operator << failed", result_value1.str(), "{ -31.034, 231.234, 3451.34, -341 }");
  573. LLQuaternion c(1.0f, 2.2f, 3.3f, 4.4f); 
  574. result_value << c;
  575. ensure_equals("3. Operator << failed", result_value.str(), "{ 1, 1, 1, 1 }{ 1, 2.2, 3.3, 4.4 }");
  577. }
  579. template<> template<>
  580. void llquat_test_object_t::test<19>()
  581. {
  582. //test case for const char *OrderToString( const LLQuaternion::Order order ) fn
  583. const char* result = OrderToString(LLQuaternion::XYZ);
  584. ensure("1. OrderToString failed for XYZ",  (0 == strcmp("XYZ", result)));
  586. result = OrderToString(LLQuaternion::YZX);
  587. ensure("2. OrderToString failed for YZX",  (0 == strcmp("YZX", result)));
  589. result = OrderToString(LLQuaternion::ZXY);
  590. ensure(
  591. "3. OrderToString failed for ZXY",
  592. (0 == strcmp("ZXY", result)) &&
  593. (0 != strcmp("XYZ", result)) &&
  594. (0 != strcmp("YXZ", result)) &&
  595. (0 != strcmp("ZYX", result)) &&
  596. (0 != strcmp("XYZ", result)));
  598. result = OrderToString(LLQuaternion::XZY);
  599. ensure("4. OrderToString failed for XZY",  (0 == strcmp("XZY", result)));
  601. result = OrderToString(LLQuaternion::ZYX);
  602. ensure("5. OrderToString failed for ZYX",  (0 == strcmp("ZYX", result)));
  604. result = OrderToString(LLQuaternion::YXZ);
  605. ensure("6.OrderToString failed for YXZ",  (0 == strcmp("YXZ", result)));
  606. }
  608. template<> template<>
  609. void llquat_test_object_t::test<20>()
  610. {
  611. //test case for LLQuaternion::Order StringToOrder( const char *str ) fn
  612. int result = StringToOrder("XYZ");
  613. ensure("1. LLQuaternion::Order StringToOrder(const char *str ) failed for XYZ", 0 == result);
  615. result = StringToOrder("YZX");
  616. ensure("2. LLQuaternion::Order StringToOrder(const char *str) failed for YZX", 1 == result);
  618. result = StringToOrder("ZXY");
  619. ensure("3. LLQuaternion::Order StringToOrder(const char *str) failed for ZXY", 2 == result);
  621. result = StringToOrder("XZY");
  622. ensure("4. LLQuaternion::Order StringToOrder(const char *str) failed for XZY", 3 == result);
  624. result = StringToOrder("YXZ");
  625. ensure("5. LLQuaternion::Order StringToOrder(const char *str) failed for YXZ", 4 == result);
  627. result = StringToOrder("ZYX");
  628. ensure("6. LLQuaternion::Order StringToOrder(const char *str) failed for  ZYX", 5 == result);
  630. }
  632. template<> template<>
  633. void llquat_test_object_t::test<21>()
  634. {
  635. //void LLQuaternion::getAngleAxis(F32* angle, LLVector3 &vec) const fn
  636. F32 angle_value = 90.0f;
  637. LLVector3 vect(12.0f, 4.0f, 1.0f);
  638. LLQuaternion llquat(angle_value, vect);
  639. llquat.getAngleAxis(&angle_value, vect); 
  640. ensure(
  641. "LLQuaternion::getAngleAxis(F32* angle, LLVector3 &vec) failed", 
  642. is_approx_equal_fraction(2.035406f, angle_value, 16) &&
  643. is_approx_equal_fraction(0.315244f, vect.mV[1], 16) &&
  644. is_approx_equal_fraction(0.078811f, vect.mV[2], 16) &&
  645. is_approx_equal_fraction(0.945733f, vect.mV[0], 16));
  646. }
  648. template<> template<>
  649. void llquat_test_object_t::test<22>()
  650. {
  651. //test case for void LLQuaternion::getEulerAngles(F32 *roll, F32 *pitch, F32 *yaw) const fn
  652. F32 roll = -12.0f;
  653. F32 pitch = -22.43f;
  654. F32 yaw = 11.0f;
  656. LLQuaternion llquat;
  657. llquat.getEulerAngles(&roll, &pitch, &yaw);
  658. ensure(
  659. "LLQuaternion::getEulerAngles(F32 *roll, F32 *pitch, F32 *yaw) failed",
  660. is_approx_equal(0.000f, llquat.mQ[0]) &&
  661. is_approx_equal(0.000f, llquat.mQ[1]) &&
  662. is_approx_equal(0.000f, llquat.mQ[2]) &&
  663. is_approx_equal(1.000f, llquat.mQ[3]));
  664. }
  666. }