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

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

游戏引擎

开发平台：

C++ Builder

v3math_test.cpp：源码内容
  1. /**
  2.  * @file v3math_test.cpp
  3.  * @author Adroit
  4.  * @date 2007-02
  5.  * @brief v3math test cases.
  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.  */
  34.  
  35. #include "linden_common.h"
  36. #include "../test/lltut.h"
  37. #include "llsd.h"
  39. #include "../llquaternion.h"
  40. #include "../llquantize.h"
  41. #include "../v3dmath.h"
  42. #include "../m3math.h"
  43. #include "../v4math.h"
  44. #include "../v3math.h"
  47. namespace tut
  48. {
  49. struct v3math_data
  50. {
  51. };
  52. typedef test_group<v3math_data> v3math_test;
  53. typedef v3math_test::object v3math_object;
  54. tut::v3math_test v3math_testcase("v3math");
  56. template<> template<>
  57. void v3math_object::test<1>()
  58. {
  59. LLVector3 vec3;
  60. ensure("1:LLVector3:Fail to initialize ", ((0.f == vec3.mV[VX]) && (0.f == vec3.mV[VY]) && (0.f == vec3.mV[VZ])));
  61. F32 x = 2.32f, y = 1.212f, z = -.12f;
  62. LLVector3 vec3a(x,y,z);
  63. ensure("2:LLVector3:Fail to initialize ", ((2.32f == vec3a.mV[VX]) && (1.212f == vec3a.mV[VY]) && (-.12f == vec3a.mV[VZ])));
  64. const F32 vec[3] = {1.2f ,3.2f, -4.2f};
  65. LLVector3 vec3b(vec);
  66. ensure("3:LLVector3:Fail to initialize ", ((1.2f == vec3b.mV[VX]) && (3.2f == vec3b.mV[VY]) && (-4.2f == vec3b.mV[VZ])));
  67. }
  69. template<> template<>
  70. void v3math_object::test<2>()
  71. {
  72. F32 x = 2.32f, y = 1.212f, z = -.12f;
  73. LLVector3 vec3(x,y,z);
  74. LLVector3d vector3d(vec3);
  75. LLVector3 vec3a(vector3d);
  76. ensure("1:LLVector3:Fail to initialize ", vec3 == vec3a);
  77. LLVector4 vector4(vec3);
  78. LLVector3 vec3b(vector4);
  79. ensure("2:LLVector3:Fail to initialize ", vec3 == vec3b);
  80. }
  82. template<> template<>
  83. void v3math_object::test<3>()
  84. {
  85. S32 a = 231;
  86. LLSD llsd(a);
  87. LLVector3 vec3(llsd);
  88. LLSD sd = vec3.getValue();
  89. LLVector3 vec3a(sd);
  90. ensure("1:LLVector3:Fail to initialize ", (vec3 == vec3a));
  91. }
  93. template<> template<>
  94. void v3math_object::test<4>()
  95. {
  96. S32 a = 231;
  97. LLSD llsd(a);
  98. LLVector3 vec3(llsd),vec3a;
  99. vec3a = vec3;
  100. ensure("1:Operator= Fail to initialize " ,(vec3 == vec3a));
  101. }
  103. template<> template<>
  104. void v3math_object::test<5>()
  105. {
  106. F32 x = 2.32f, y = 1.212f, z = -.12f;
  107. LLVector3 vec3(x,y,z);
  108. ensure("1:isFinite= Fail to initialize ", (TRUE == vec3.isFinite()));//need more test cases:
  109. vec3.clearVec();
  110. ensure("2:clearVec:Fail to set values ", ((0.f == vec3.mV[VX]) && (0.f == vec3.mV[VY]) && (0.f == vec3.mV[VZ])));
  111. vec3.setVec(x,y,z);
  112. ensure("3:setVec:Fail to set values ", ((2.32f == vec3.mV[VX]) && (1.212f == vec3.mV[VY]) && (-.12f == vec3.mV[VZ])));
  113. vec3.zeroVec();
  114. ensure("4:zeroVec:Fail to set values ", ((0.f == vec3.mV[VX]) && (0.f == vec3.mV[VY]) && (0.f == vec3.mV[VZ])));
  115. }
  117. template<> template<>
  118. void v3math_object::test<6>()
  119. {
  120. F32 x = 2.32f, y = 1.212f, z = -.12f;
  121. LLVector3 vec3(x,y,z),vec3a;
  122. vec3.abs();
  123. ensure("1:abs:Fail ", ((x == vec3.mV[VX]) && (y == vec3.mV[VY]) && (-z == vec3.mV[VZ])));
  124. vec3a.setVec(vec3);
  125. ensure("2:setVec:Fail to initialize ", (vec3a == vec3));
  126. const F32 vec[3] = {1.2f ,3.2f, -4.2f};
  127. vec3.clearVec();
  128. vec3.setVec(vec);
  129. ensure("3:setVec:Fail to initialize ", ((1.2f == vec3.mV[VX]) && (3.2f == vec3.mV[VY]) && (-4.2f == vec3.mV[VZ])));
  130. vec3a.clearVec();
  131. LLVector3d vector3d(vec3);
  132. vec3a.setVec(vector3d);
  133. ensure("4:setVec:Fail to initialize ", (vec3 == vec3a));
  134. LLVector4 vector4(vec3);
  135. vec3a.clearVec();
  136. vec3a.setVec(vector4);
  137. ensure("5:setVec:Fail to initialize ", (vec3 == vec3a));
  138. }
  140. template<> template<>
  141. void v3math_object::test<7>()
  142. {
  143. F32 x = 2.32f, y = 3.212f, z = -.12f;
  144. F32 min = 0.0001f, max = 3.0f;
  145. LLVector3 vec3(x,y,z);
  146. ensure("1:clamp:Fail  ", TRUE == vec3.clamp(min, max) && x == vec3.mV[VX] && max == vec3.mV[VY] && min == vec3.mV[VZ]);
  147. x = 1.f, y = 2.2f, z = 2.8f;
  148. vec3.setVec(x,y,z);
  149. ensure("2:clamp:Fail  ", FALSE == vec3.clamp(min, max));
  150. }
  152. template<> template<>
  153. void v3math_object::test<8>()
  154. {
  155. F32 x = 2.32f, y = 1.212f, z = -.12f;
  156. LLVector3 vec3(x,y,z);
  157. ensure("1:magVecSquared:Fail ", is_approx_equal(vec3.magVecSquared(), (x*x + y*y + z*z)));
  158. ensure("2:magVec:Fail ", is_approx_equal(vec3.magVec(), fsqrtf(x*x + y*y + z*z)));
  159. }
  161. template<> template<>
  162. void v3math_object::test<9>()
  163. {
  164. F32 x =-2.0f, y = -3.0f, z = 1.23f ;
  165. LLVector3 vec3(x,y,z);
  166. ensure("1:abs():Fail ", (TRUE == vec3.abs()));
  167. ensure("2:isNull():Fail", (FALSE == vec3.isNull())); //Returns TRUE if vector has a _very_small_ length
  168. x =.00000001f, y = .000001001f, z = .000001001f;
  169. vec3.setVec(x,y,z);
  170. ensure("3:isNull(): Fail ", (TRUE == vec3.isNull()));
  171. }
  173. template<> template<>
  174. void v3math_object::test<10>()
  175. {
  176. F32 x =-2.0f, y = -3.0f, z = 1.f ;
  177. LLVector3 vec3(x,y,z),vec3a;
  178. ensure("1:isExactlyZero():Fail ", (TRUE == vec3a.isExactlyZero()));
  179. vec3a = vec3a.scaleVec(vec3);
  180. ensure("2:scaleVec: Fail ", vec3a.mV[VX] == 0.f && vec3a.mV[VY] == 0.f && vec3a.mV[VZ] == 0.f);
  181. vec3a.setVec(x,y,z);
  182. vec3a = vec3a.scaleVec(vec3);
  183. ensure("3:scaleVec: Fail ", ((4 == vec3a.mV[VX]) && (9 == vec3a.mV[VY]) &&(1 == vec3a.mV[VZ])));
  184. ensure("4:isExactlyZero():Fail ", (FALSE == vec3.isExactlyZero()));
  185. }
  187. template<> template<>
  188. void v3math_object::test<11>()
  189. {
  190. F32 x =20.0f, y = 30.0f, z = 15.f ;
  191. F32 angle = 100.f;
  192. LLVector3 vec3(x,y,z),vec3a(1.f,2.f,3.f);
  193. vec3a = vec3a.rotVec(angle, vec3);
  194. LLVector3 vec3b(1.f,2.f,3.f);
  195. vec3b = vec3b.rotVec(angle, vec3);
  196. ensure_equals("rotVec():Fail" ,vec3b,vec3a);
  197. }
  199. template<> template<>
  200. void v3math_object::test<12>()
  201. {
  202. F32 x =-2.0f, y = -3.0f, z = 1.f ;
  203. LLVector3 vec3(x,y,z);
  204. ensure("1:operator [] failed",( x ==  vec3[0]));
  205. ensure("2:operator [] failed",( y ==  vec3[1]));
  206. ensure("3:operator [] failed",( z ==  vec3[2]));
  208. vec3.clearVec();
  209. x = 23.f, y = -.2361f, z = 3.25;
  210. vec3.setVec(x,y,z);
  211. F32 &ref1 = vec3[0];
  212. ensure("4:operator [] failed",( ref1 ==  vec3[0]));
  213. F32 &ref2 = vec3[1];
  214. ensure("5:operator [] failed",( ref2 ==  vec3[1]));
  215. F32 &ref3 = vec3[2];
  216. ensure("6:operator [] failed",( ref3 ==  vec3[2]));
  217. }
  219. template<> template<>
  220. void v3math_object::test<13>()
  221. {
  222. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
  223. F32 val1, val2, val3;
  224. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2), vec3b;
  225. vec3b = vec3 + vec3a ;
  226. val1 = x1+x2;
  227. val2 = y1+y2;
  228. val3 = z1+z2;
  229. ensure("1:operator+ failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ])); 
  231. vec3.clearVec();
  232. vec3a.clearVec();
  233. vec3b.clearVec();
  234. x1 = -.235f, y1 = -24.32f,z1 = 2.13f,  x2 = -2.3f, y2 = 1.f, z2 = 34.21f;
  235. vec3.setVec(x1,y1,z1);
  236. vec3a.setVec(x2,y2,z2);
  237. vec3b = vec3 + vec3a;
  238. val1 = x1+x2;
  239. val2 = y1+y2;
  240. val3 = z1+z2;
  241. ensure("2:operator+ failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ])); 
  242. }
  244. template<> template<>
  245. void v3math_object::test<14>()
  246. {
  247. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
  248. F32 val1, val2, val3;
  249. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2), vec3b;
  250. vec3b = vec3 - vec3a ;
  251. val1 = x1-x2;
  252. val2 = y1-y2;
  253. val3 = z1-z2;
  254. ensure("1:operator- failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ])); 
  256. vec3.clearVec();
  257. vec3a.clearVec();
  258. vec3b.clearVec();
  259. x1 = -.235f, y1 = -24.32f,z1 = 2.13f,  x2 = -2.3f, y2 = 1.f, z2 = 34.21f;
  260. vec3.setVec(x1,y1,z1);
  261. vec3a.setVec(x2,y2,z2);
  262. vec3b = vec3 - vec3a;
  263. val1 = x1-x2;
  264. val2 = y1-y2;
  265. val3 = z1-z2;
  266. ensure("2:operator- failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ])); 
  267. }
  269. template<> template<>
  270. void v3math_object::test<15>()
  271. {
  272. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
  273. F32 val1, val2, val3;
  274. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
  275. val1 = vec3 * vec3a;
  276. val2 = x1*x2 + y1*y2 + z1*z2;
  277. ensure_equals("1:operator* failed",val1,val2);
  279. vec3a.clearVec();
  280. F32 mulVal = 4.332f;
  281. vec3a = vec3 * mulVal;
  282. val1 = x1*mulVal;
  283. val2 = y1*mulVal;
  284. val3 = z1*mulVal;
  285. ensure("2:operator* failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
  286. vec3a.clearVec();
  287. vec3a = mulVal * vec3;
  288. ensure("3:operator* failed ", (val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
  289. }
  291. template<> template<>
  292. void v3math_object::test<16>()
  293. {
  294. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
  295. F32 val1, val2, val3;
  296. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2), vec3b;
  297. vec3b = vec3 % vec3a ;
  298. val1 = y1*z2 - y2*z1;
  299. val2 = z1*x2 -z2*x1;
  300. val3 = x1*y2-x2*y1;
  301. ensure("1:operator% failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ])); 
  303. vec3.clearVec();
  304. vec3a.clearVec();
  305. vec3b.clearVec();
  306. x1 =112.f, y1 = 22.3f,z1 = 1.2f, x2 = -2.3f, y2 = 341.11f, z2 = 1234.234f;
  307. vec3.setVec(x1,y1,z1);
  308. vec3a.setVec(x2,y2,z2);
  309. vec3b = vec3 % vec3a ;
  310. val1 = y1*z2 - y2*z1;
  311. val2 = z1*x2 -z2*x1;
  312. val3 = x1*y2-x2*y1;
  313. ensure("2:operator% failed ", (val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ])); 
  314. }
  316. template<> template<>
  317. void v3math_object::test<17>()
  318. {
  319. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, div = 3.2f;
  320. F32 t = 1.f / div, val1, val2, val3;
  321. LLVector3 vec3(x1,y1,z1), vec3a;
  322. vec3a = vec3 / div;
  323. val1 = x1 * t;
  324. val2 = y1 * t;
  325. val3 = z1 *t;
  326. ensure("1:operator/ failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY]) && (val3 == vec3a.mV[VZ]));
  328. vec3a.clearVec();
  329. x1 = -.235f, y1 = -24.32f, z1 = .342f, div = -2.2f;
  330. t = 1.f / div;
  331. vec3.setVec(x1,y1,z1);
  332. vec3a = vec3 / div;
  333. val1 = x1 * t;
  334. val2 = y1 * t;
  335. val3 = z1 *t;
  336. ensure("2:operator/ failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY]) && (val3 == vec3a.mV[VZ]));
  337. }
  339. template<> template<>
  340. void v3math_object::test<18>()
  341. {
  342. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f;
  343. LLVector3 vec3(x1,y1,z1), vec3a(x1,y1,z1);
  344. ensure("1:operator== failed",(vec3 == vec3a));
  346. vec3a.clearVec();
  347. x1 = -.235f, y1 = -24.32f, z1 = .342f;
  348. vec3.clearVec();
  349. vec3a.clearVec();
  350. vec3.setVec(x1,y1,z1);
  351. vec3a.setVec(x1,y1,z1);
  352. ensure("2:operator== failed ", (vec3 == vec3a));
  353. }
  355. template<> template<>
  356. void v3math_object::test<19>()
  357. {
  358. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 =112.f, y2 = 2.234f,z2 = 11.2f;;
  359. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
  360. ensure("1:operator!= failed",(vec3a != vec3));
  362. vec3.clearVec();
  363. vec3.clearVec();
  364. vec3a.setVec(vec3);
  365. ensure("2:operator!= failed", ( FALSE == (vec3a != vec3)));
  366. }
  368. template<> template<>
  369. void v3math_object::test<20>()
  370. {
  371. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 =112.f, y2 = 2.2f,z2 = 11.2f;;
  372. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
  373. vec3a += vec3;
  374. F32 val1, val2, val3;
  375. val1 = x1+x2;
  376. val2 = y1+y2;
  377. val3 = z1+z2;
  378. ensure("1:operator+= failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
  379. }
  381. template<> template<>
  382. void v3math_object::test<21>()
  383. {
  384. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 =112.f, y2 = 2.2f,z2 = 11.2f;;
  385. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
  386. vec3a -= vec3;
  387. F32 val1, val2, val3;
  388. val1 = x2-x1;
  389. val2 = y2-y1;
  390. val3 = z2-z1;
  391. ensure("1:operator-= failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
  392. }
  394. template<> template<>
  395. void v3math_object::test<22>()
  396. {
  397. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
  398. F32 val1,val2,val3;
  399. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
  400. vec3a *= vec3;
  401. val1 = x1*x2;
  402. val2 = y1*y2;
  403. val3 = z1*z2;
  404. ensure("1:operator*= failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
  406. F32 mulVal = 4.332f;
  407. vec3 *=mulVal;
  408. val1 = x1*mulVal;
  409. val2 = y1*mulVal;
  410. val3 = z1*mulVal;
  411. ensure("2:operator*= failed ", is_approx_equal(val1, vec3.mV[VX]) && is_approx_equal(val2, vec3.mV[VY]) && is_approx_equal(val3, vec3.mV[VZ]));
  412. }
  414. template<> template<>
  415. void v3math_object::test<23>()
  416. {
  417. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
  418. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2),vec3b;
  419. vec3b = vec3a % vec3;
  420. vec3a %= vec3;
  421. ensure_equals("1:operator%= failed",vec3a,vec3b); 
  422. }
  424. template<> template<>
  425. void v3math_object::test<24>()
  426. {
  427. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, div = 3.2f;
  428. F32 t = 1.f / div, val1, val2, val3;
  429. LLVector3 vec3a(x1,y1,z1);
  430. vec3a /= div;
  431. val1 = x1 * t;
  432. val2 = y1 * t;
  433. val3 = z1 *t;
  434. ensure("1:operator/= failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY]) && (val3 == vec3a.mV[VZ]));
  435. }
  437. template<> template<>
  438. void v3math_object::test<25>()
  439. {
  440. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f;
  441. LLVector3 vec3(x1,y1,z1), vec3a;
  442. vec3a = -vec3;
  443. ensure("1:operator- failed",(-vec3a == vec3));
  444. }
  446. template<> template<>
  447. void v3math_object::test<26>()
  448. {
  449. F32 x1 =1.f, y1 = 2.f,z1 = 1.2f;
  450. std::ostringstream stream1, stream2;
  451. LLVector3 vec3(x1,y1,z1), vec3a;
  452. stream1 << vec3;
  453. vec3a.setVec(x1,y1,z1);
  454. stream2 << vec3a;
  455. ensure("1:operator << failed",(stream1.str() == stream2.str()));
  456. }
  458. template<> template<>
  459. void v3math_object::test<27>()
  460. {
  461. F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.11f, z2 = 1234.234f;
  462. LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
  463. ensure("1:operator< failed", (TRUE == (vec3 < vec3a)));
  464. x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 2.f, z2 = 1234.234f;
  465. vec3.setVec(x1,y1,z1);
  466. vec3a.setVec(x2,y2,z2);
  467. ensure("2:operator< failed ", (TRUE == (vec3 < vec3a)));
  468. x1 =2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f,
  469. vec3.setVec(x1,y1,z1);
  470. vec3a.setVec(x2,y2,z2);
  471. ensure("3:operator< failed ", (FALSE == (vec3 < vec3a)));
  472. }
  474. template<> template<>
  475. void v3math_object::test<28>()
  476. {
  477. F32 x1 =1.23f, y1 = 2.f,z1 = 4.f;
  478. std::string buf("1.23 2. 4");
  479. LLVector3 vec3, vec3a(x1,y1,z1);
  480. LLVector3::parseVector3(buf, &vec3);
  481. ensure_equals("1:parseVector3 failed", vec3, vec3a);
  482. }
  484. template<> template<>
  485. void v3math_object::test<29>()
  486. {
  487. F32 x1 =1.f, y1 = 2.f,z1 = 4.f;
  488. LLVector3 vec3(x1,y1,z1),vec3a,vec3b;
  489. vec3a.setVec(1,1,1);
  490. vec3a.scaleVec(vec3);
  491. ensure_equals("1:scaleVec failed", vec3, vec3a);
  492. vec3a.clearVec();
  493. vec3a.setVec(x1,y1,z1);
  494. vec3a.scaleVec(vec3);
  495. ensure("2:scaleVec failed", ((1.f ==vec3a.mV[VX])&& (4.f ==vec3a.mV[VY]) && (16.f ==vec3a.mV[VZ])));
  496. }
  498. template<> template<>
  499. void v3math_object::test<30>()
  500. {
  501. F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.11f, z2 = 1234.234f;
  502. F32 val = 2.3f,val1,val2,val3;
  503. val1 = x1 + (x2 - x1)* val;
  504. val2 = y1 + (y2 - y1)* val;
  505. val3 = z1 + (z2 - z1)* val;
  506. LLVector3 vec3(x1,y1,z1),vec3a(x2,y2,z2);
  507. LLVector3 vec3b = lerp(vec3,vec3a,val);
  508. ensure("1:lerp failed", ((val1 ==vec3b.mV[VX])&& (val2 ==vec3b.mV[VY]) && (val3 ==vec3b.mV[VZ])));
  509. }
  511. template<> template<>
  512. void v3math_object::test<31>()
  513. {
  514. F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.f, z2 = 1.f;
  515. F32 val1,val2;
  516. LLVector3 vec3(x1,y1,z1),vec3a(x2,y2,z2);
  517. val1 = dist_vec(vec3,vec3a);
  518. val2 = fsqrtf((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
  519. ensure_equals("1:dist_vec: Fail ",val2, val1);
  520. val1 = dist_vec_squared(vec3,vec3a);
  521. val2 =((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
  522. ensure_equals("2:dist_vec_squared: Fail ",val2, val1);
  523. val1 = dist_vec_squared2D(vec3, vec3a);
  524. val2 =(x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2);
  525. ensure_equals("3:dist_vec_squared2D: Fail ",val2, val1);
  526. }
  528. template<> template<>
  529. void v3math_object::test<32>()
  530. {
  531. F32 x =12.3524f, y = -342.f,z = 4.126341f;
  532. LLVector3 vec3(x,y,z);
  533. F32 mag = vec3.normVec();
  534. mag = 1.f/ mag;
  535. F32 val1 = x* mag, val2 = y* mag, val3 = z* mag;
  536. ensure("1:normVec: Fail ", is_approx_equal(val1, vec3.mV[VX]) && is_approx_equal(val2, vec3.mV[VY]) && is_approx_equal(val3, vec3.mV[VZ]));
  537. x = 0.000000001f, y = 0.f, z = 0.f;
  538. vec3.clearVec();
  539. vec3.setVec(x,y,z);
  540. mag = vec3.normVec();
  541. val1 = x* mag, val2 = y* mag, val3 = z* mag;
  542. ensure("2:normVec: Fail ", (mag == 0.) && (0. == vec3.mV[VX]) && (0. == vec3.mV[VY])&& (0. == vec3.mV[VZ]));
  543. }
  545. template<> template<>
  546. void v3math_object::test<33>()
  547. {
  548. F32 x = -202.23412f, y = 123.2312f, z = -89.f;
  549. LLVector3 vec(x,y,z);
  550. vec.snap(2);
  551. ensure("1:snap: Fail ", is_approx_equal(-202.23f, vec.mV[VX]) && is_approx_equal(123.23f, vec.mV[VY]) && is_approx_equal(-89.f, vec.mV[VZ]));
  552. }
  554. template<> template<>
  555. void v3math_object::test<34>()
  556. {
  557. F32 x = 10.f, y = 20.f, z = -15.f;
  558. F32 x1, y1, z1;
  559. F32 lowerxy = 0.f, upperxy = 1.0f, lowerz = -1.0f, upperz = 1.f;
  560. LLVector3 vec3(x,y,z);
  561. vec3.quantize16(lowerxy,upperxy,lowerz,upperz);
  562. x1 = U16_to_F32(F32_to_U16(x, lowerxy, upperxy), lowerxy, upperxy);
  563. y1 = U16_to_F32(F32_to_U16(y, lowerxy, upperxy), lowerxy, upperxy);
  564. z1 = U16_to_F32(F32_to_U16(z, lowerz,  upperz),  lowerz,  upperz);
  565. ensure("1:quantize16: Fail ", is_approx_equal(x1, vec3.mV[VX]) && is_approx_equal(y1, vec3.mV[VY]) && is_approx_equal(z1, vec3.mV[VZ]));
  566. LLVector3 vec3a(x,y,z);
  567. vec3a.quantize8(lowerxy,upperxy,lowerz,upperz);
  568. x1 = U8_to_F32(F32_to_U8(x, lowerxy, upperxy), lowerxy, upperxy);
  569. y1 = U8_to_F32(F32_to_U8(y, lowerxy, upperxy), lowerxy, upperxy);
  570. z1 = U8_to_F32(F32_to_U8(z, lowerz, upperz), lowerz, upperz);
  571. ensure("2:quantize8: Fail ", is_approx_equal(x1, vec3a.mV[VX]) && is_approx_equal(y1, vec3a.mV[VY]) && is_approx_equal(z1, vec3a.mV[VZ]));
  572. }
  573. }