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

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

游戏引擎

开发平台：

C++ Builder

v4math_test.cpp：源码内容
  1. /**
  2.  * @file v4math_test.cpp
  3.  * @author Adroit
  4.  * @date 2007-03
  5.  * @brief v4math 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 "../m4math.h"
  41. #include "../v4math.h"
  43. namespace tut
  44. {
  45. struct v4math_data
  46. {
  47. };
  48. typedef test_group<v4math_data> v4math_test;
  49. typedef v4math_test::object v4math_object;
  50. tut::v4math_test v4math_testcase("v4math");
  52. template<> template<>
  53. void v4math_object::test<1>()
  54. {
  55. LLVector4 vec4;
  56. ensure("1:LLVector4:Fail to initialize " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
  57. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  58. LLVector4 vec4a(x,y,z);
  59. ensure("2:LLVector4:Fail to initialize " ,((x == vec4a.mV[VX]) && (y == vec4a.mV[VY]) && (z == vec4a.mV[VZ])&& (1.0f == vec4a.mV[VW])));
  60. LLVector4 vec4b(x,y,z,w);
  61. ensure("3:LLVector4:Fail to initialize " ,((x == vec4b.mV[VX]) && (y == vec4b.mV[VY]) && (z == vec4b.mV[VZ])&& (w == vec4b.mV[VW])));
  62. const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
  63. LLVector4 vec4c(vec);
  64. ensure("4:LLVector4:Fail to initialize " ,((vec[0] == vec4c.mV[VX]) && (vec[1] == vec4c.mV[VY]) && (vec[2] == vec4c.mV[VZ])&& (vec[3] == vec4c.mV[VW])));
  65. LLVector3 vec3(-2.23f,1.01f,42.3f);
  66. LLVector4 vec4d(vec3);
  67. ensure("5:LLVector4:Fail to initialize " ,((vec3.mV[VX] == vec4d.mV[VX]) && (vec3.mV[VY] == vec4d.mV[VY]) && (vec3.mV[VZ] == vec4d.mV[VZ])&& (1.f == vec4d.mV[VW])));
  68. F32 w1 = -.234f;
  69. LLVector4 vec4e(vec3,w1);
  70. ensure("6:LLVector4:Fail to initialize " ,((vec3.mV[VX] == vec4e.mV[VX]) && (vec3.mV[VY] == vec4e.mV[VY]) && (vec3.mV[VZ] == vec4e.mV[VZ])&& (w1 == vec4e.mV[VW])));
  71. }
  73. template<> template<>
  74. void v4math_object::test<2>()
  75. {
  76. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  77. LLVector4 vec4;
  78. vec4.setVec(x,y,z);
  79. ensure("1:setVec:Fail to initialize " ,((x == vec4.mV[VX]) && (y == vec4.mV[VY]) && (z == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
  80. vec4.clearVec();
  81. ensure("2:clearVec:Fail " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
  82. vec4.setVec(x,y,z,w);
  83. ensure("3:setVec:Fail to initialize " ,((x == vec4.mV[VX]) && (y == vec4.mV[VY]) && (z == vec4.mV[VZ])&& (w == vec4.mV[VW])));
  84. vec4.zeroVec();
  85. ensure("4:zeroVec:Fail " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (0 == vec4.mV[VW])));
  86. LLVector3 vec3(-2.23f,1.01f,42.3f);
  87. vec4.clearVec();
  88. vec4.setVec(vec3);
  89. ensure("5:setVec:Fail to initialize " ,((vec3.mV[VX] == vec4.mV[VX]) && (vec3.mV[VY] == vec4.mV[VY]) && (vec3.mV[VZ] == vec4.mV[VZ])&& (1.f == vec4.mV[VW])));
  90. F32 w1 = -.234f;
  91. vec4.zeroVec();
  92. vec4.setVec(vec3,w1);
  93. ensure("6:setVec:Fail to initialize " ,((vec3.mV[VX] == vec4.mV[VX]) && (vec3.mV[VY] == vec4.mV[VY]) && (vec3.mV[VZ] == vec4.mV[VZ])&& (w1 == vec4.mV[VW])));
  94. const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
  95. LLVector4 vec4a;
  96. vec4a.setVec(vec);
  97. ensure("7:setVec:Fail to initialize " ,((vec[0] == vec4a.mV[VX]) && (vec[1] == vec4a.mV[VY]) && (vec[2] == vec4a.mV[VZ])&& (vec[3] == vec4a.mV[VW])));
  98. }
  100. template<> template<>
  101. void v4math_object::test<3>()
  102. {
  103. F32 x = 10.f, y = -2.3f, z = -.023f;
  104. LLVector4 vec4(x,y,z);
  105. ensure("magVec:Fail ", is_approx_equal(vec4.magVec(), fsqrtf(x*x + y*y + z*z)));
  106. ensure("magVecSquared:Fail ", is_approx_equal(vec4.magVecSquared(), (x*x + y*y + z*z)));
  107. }
  109. template<> template<>
  110. void v4math_object::test<4>()
  111. {
  112. F32 x = 10.f, y = -2.3f, z = -.023f;
  113. LLVector4 vec4(x,y,z);
  114. F32 mag = vec4.normVec();
  115. mag = 1.f/ mag;
  116. ensure("1:normVec: Fail " ,is_approx_equal(mag*x,vec4.mV[VX]) && is_approx_equal(mag*y, vec4.mV[VY])&& is_approx_equal(mag*z, vec4.mV[VZ]));
  117. x = 0.000000001f, y = 0.000000001f, z = 0.000000001f;
  118. vec4.clearVec();
  119. vec4.setVec(x,y,z);
  120. mag = vec4.normVec();
  121. ensure("2:normVec: Fail " ,is_approx_equal(mag*x,vec4.mV[VX]) && is_approx_equal(mag*y, vec4.mV[VY])&& is_approx_equal(mag*z, vec4.mV[VZ]));
  122. }
  124. template<> template<>
  125. void v4math_object::test<5>()
  126. {
  127. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  128. LLVector4 vec4(x,y,z,w);
  129. vec4.abs();
  130. ensure("abs:Fail " ,((x == vec4.mV[VX]) && (-y == vec4.mV[VY]) && (-z == vec4.mV[VZ])&& (-w == vec4.mV[VW])));
  131. vec4.clearVec();
  132. ensure("isExactlyClear:Fail " ,(TRUE == vec4.isExactlyClear()));
  133. vec4.zeroVec();
  134. ensure("isExactlyZero:Fail " ,(TRUE == vec4.isExactlyZero()));
  135. }
  137. template<> template<>
  138. void v4math_object::test<6>()
  139. {
  140. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  141. LLVector4 vec4(x,y,z,w),vec4a;
  142. vec4a = vec4.scaleVec(vec4);
  143. ensure("scaleVec:Fail " ,(is_approx_equal(x*x, vec4a.mV[VX]) && is_approx_equal(y*y, vec4a.mV[VY]) && is_approx_equal(z*z, vec4a.mV[VZ])&& is_approx_equal(w*w, vec4a.mV[VW])));
  144. }
  146. template<> template<>
  147. void v4math_object::test<7>()
  148. {
  149. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  150. LLVector4 vec4(x,y,z,w);
  151. ensure("1:operator [] failed " ,( x ==  vec4[0]));
  152. ensure("2:operator [] failed " ,( y ==  vec4[1]));
  153. ensure("3:operator [] failed " ,( z ==  vec4[2]));
  154. ensure("4:operator [] failed " ,( w ==  vec4[3]));
  155. x = 23.f, y = -.2361f, z = 3.25;
  156. vec4.setVec(x,y,z);
  157. F32 &ref1 = vec4[0];
  158. ensure("5:operator [] failed " ,( ref1 ==  vec4[0]));
  159. F32 &ref2 = vec4[1];
  160. ensure("6:operator [] failed " ,( ref2 ==  vec4[1]));
  161. F32 &ref3 = vec4[2];
  162. ensure("7:operator [] failed " ,( ref3 ==  vec4[2]));
  163. F32 &ref4 = vec4[3];
  164. ensure("8:operator [] failed " ,( ref4 ==  vec4[3]));
  165. }
  167. template<> template<>
  168. void v4math_object::test<8>()
  169. {
  170. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  171. const  F32 val[16] = {
  172.             1.f,  2.f,   3.f,    0.f,
  173.             .34f, .1f,   -.5f,   0.f,
  174.             2.f,  1.23f, 1.234f, 0.f,
  175.             .89f, 0.f,   0.f,    0.f
  176.         };
  177. LLMatrix4 mat(val);
  178. LLVector4 vec4(x,y,z,w),vec4a;
  179. vec4.rotVec(mat);
  180. vec4a.setVec(x,y,z,w);
  181. vec4a.rotVec(mat);
  182. ensure_equals("1:rotVec: Fail " ,vec4a, vec4);
  183. F32 a = 2.32f, b = -23.2f, c = -34.1112f, d = 1.010112f;
  184. LLQuaternion q(a,b,c,d);
  185. LLVector4 vec4b(a,b,c,d),vec4c;
  186. vec4b.rotVec(q);
  187. vec4c.setVec(a, b, c, d);
  188. vec4c.rotVec(q);
  189. ensure_equals("2:rotVec: Fail " ,vec4b, vec4c);
  190. }
  192. template<> template<>
  193. void v4math_object::test<9>()
  194. {
  195. F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
  196. LLVector4 vec4(x,y,z,w),vec4a;;
  197. std::ostringstream stream1, stream2;
  198. stream1 << vec4;
  199. vec4a.setVec(x,y,z,w);
  200. stream2 << vec4a;
  201. ensure("operator << failed",(stream1.str() == stream2.str()));
  202. }
  204. template<> template<>
  205. void v4math_object::test<10>()
  206. {
  207. F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f;
  208. F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f;
  209. LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b;
  210. vec4b = vec4a + vec4;
  211. ensure("1:operator+:Fail to initialize " ,(is_approx_equal(x1+x2,vec4b.mV[VX]) && is_approx_equal(y1+y2,vec4b.mV[VY]) && is_approx_equal(z1+z2,vec4b.mV[VZ])));
  212. x1 = -2.45f, y1 = 2.1f, z1 = 3.0f;
  213. vec4.clearVec();
  214. vec4a.clearVec();
  215. vec4.setVec(x1,y1,z1);
  216. vec4a +=vec4;
  217. ensure_equals("2:operator+=: Fail to initialize", vec4a,vec4);
  218. vec4a += vec4;
  219. ensure("3:operator+=:Fail to initialize " ,(is_approx_equal(2*x1,vec4a.mV[VX]) && is_approx_equal(2*y1,vec4a.mV[VY]) && is_approx_equal(2*z1,vec4a.mV[VZ])));
  220. }
  221. template<> template<>
  222. void v4math_object::test<11>()
  223. {
  224. F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f;
  225. F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f;
  226. LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b;
  227. vec4b = vec4a - vec4;
  228. ensure("1:operator-:Fail to initialize " ,(is_approx_equal(x2-x1,vec4b.mV[VX]) && is_approx_equal(y2-y1,vec4b.mV[VY]) && is_approx_equal(z2-z1,vec4b.mV[VZ])));
  229. x1 = -2.45f, y1 = 2.1f, z1 = 3.0f;
  230. vec4.clearVec();
  231. vec4a.clearVec();
  232. vec4.setVec(x1,y1,z1);
  233. vec4a -=vec4;
  234. ensure_equals("2:operator-=: Fail to initialize" , vec4a,-vec4);
  235. vec4a -=vec4;
  236. ensure("3:operator-=:Fail to initialize " ,(is_approx_equal(-2*x1,vec4a.mV[VX]) && is_approx_equal(-2*y1,vec4a.mV[VY]) && is_approx_equal(-2*z1,vec4a.mV[VZ])));
  237. }
  239. template<> template<>
  240. void v4math_object::test<12>()
  241. {
  242. F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f;
  243. F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f;
  244. LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
  245. F32 res = vec4 * vec4a;
  246. ensure("1:operator* failed " ,is_approx_equal(res, x1*x2 + y1*y2 + z1*z2));
  247. vec4a.clearVec();
  248. F32 mulVal = 4.2f;
  249. vec4a = vec4 * mulVal;
  250. ensure("2:operator* failed " ,is_approx_equal(x1*mulVal,vec4a.mV[VX]) && is_approx_equal(y1*mulVal, vec4a.mV[VY])&& is_approx_equal(z1*mulVal, vec4a.mV[VZ]));
  251. vec4a.clearVec();
  252. vec4a = mulVal *  vec4 ;
  253. ensure("3:operator* failed " ,is_approx_equal(x1*mulVal, vec4a.mV[VX]) && is_approx_equal(y1*mulVal, vec4a.mV[VY])&& is_approx_equal(z1*mulVal, vec4a.mV[VZ]));
  254. vec4 *= mulVal;
  255. ensure("4:operator*= failed " ,is_approx_equal(x1*mulVal, vec4.mV[VX]) && is_approx_equal(y1*mulVal, vec4.mV[VY])&& is_approx_equal(z1*mulVal, vec4.mV[VZ]));
  256. }
  258. template<> template<>
  259. void v4math_object::test<13>()
  260. {
  261. F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f;
  262. F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f;
  263. LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2),vec4b;
  264. vec4b = vec4 % vec4a;
  265. ensure("1:operator% failed " ,is_approx_equal(y1*z2 - y2*z1, vec4b.mV[VX]) && is_approx_equal(z1*x2 -z2*x1, vec4b.mV[VY]) && is_approx_equal(x1*y2-x2*y1, vec4b.mV[VZ])); 
  266. vec4 %= vec4a;
  267. ensure_equals("operator%= failed " ,vec4,vec4b); 
  268. }
  270. template<> template<>
  271. void v4math_object::test<14>()
  272. {
  273. F32 x = 1.f, y = 2.f, z = -1.1f,div = 4.2f;
  274. F32 t = 1.f / div;
  275. LLVector4 vec4(x,y,z), vec4a;
  276. vec4a = vec4/div;
  277. ensure("1:operator/ failed " ,is_approx_equal(x*t, vec4a.mV[VX]) && is_approx_equal(y*t, vec4a.mV[VY])&& is_approx_equal(z*t, vec4a.mV[VZ]));
  278. x = 1.23f, y = 4.f, z = -2.32f;
  279. vec4.clearVec();
  280. vec4a.clearVec();
  281. vec4.setVec(x,y,z);
  282. vec4a = vec4/div;
  283. ensure("2:operator/ failed " ,is_approx_equal(x*t, vec4a.mV[VX]) && is_approx_equal(y*t, vec4a.mV[VY])&& is_approx_equal(z*t, vec4a.mV[VZ]));
  284. vec4 /= div;
  285. ensure("3:operator/ failed " ,is_approx_equal(x*t, vec4.mV[VX]) && is_approx_equal(y*t, vec4.mV[VY])&& is_approx_equal(z*t, vec4.mV[VZ]));
  286. }
  288. template<> template<>
  289. void v4math_object::test<15>()
  290. {
  291. F32 x = 1.f, y = 2.f, z = -1.1f;
  292. LLVector4 vec4(x,y,z), vec4a;
  293. ensure("operator!= failed " ,(vec4 != vec4a));
  294. vec4a = vec4;
  295. ensure("operator== failed " ,(vec4 ==vec4a)); 
  296. }
  298. template<> template<>
  299. void v4math_object::test<16>()
  300. {
  301. F32 x = 1.f, y = 2.f, z = -1.1f;
  302. LLVector4 vec4(x,y,z), vec4a;
  303. vec4a = - vec4;
  304. ensure("operator- failed " , (vec4 == - vec4a));
  305. }
  307. template<> template<>
  308. void v4math_object::test<17>()
  309. {
  310. F32 x = 1.f, y = 2.f, z = -1.1f,epsilon = .23425f;
  311. LLVector4 vec4(x,y,z), vec4a(x,y,z);
  312. ensure("1:are_parallel: Fail " ,(TRUE == are_parallel(vec4a,vec4,epsilon)));
  313. x = 21.f, y = 12.f, z = -123.1f;
  314. vec4a.clearVec();
  315. vec4a.setVec(x,y,z);
  316. ensure("2:are_parallel: Fail " ,(FALSE == are_parallel(vec4a,vec4,epsilon)));
  317. }
  319. template<> template<>
  320. void v4math_object::test<18>()
  321. {
  322. F32 x = 1.f, y = 2.f, z = -1.1f;
  323. F32 angle1, angle2;
  324. LLVector4 vec4(x,y,z), vec4a(x,y,z);
  325. angle1 = angle_between(vec4, vec4a);
  326. vec4.normVec();
  327. vec4a.normVec();
  328. angle2 = acos(vec4 * vec4a);
  329. ensure_approximately_equals("1:angle_between: Fail " ,angle1,angle2,8);
  330. F32 x1 = 21.f, y1 = 2.23f, z1 = -1.1f;
  331. LLVector4 vec4b(x,y,z), vec4c(x1,y1,z1);
  332. angle1 = angle_between(vec4b, vec4c);
  333. vec4b.normVec();
  334. vec4c.normVec();
  335. angle2 = acos(vec4b * vec4c);
  336. ensure_approximately_equals("2:angle_between: Fail " ,angle1,angle2,8);
  337. }
  339. template<> template<>
  340. void v4math_object::test<19>()
  341. {
  342. F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.f, z2 = 1.f;
  343. F32 val1,val2;
  344. LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
  345. val1 = dist_vec(vec4,vec4a);
  346. val2 = fsqrtf((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
  347. ensure_equals("dist_vec: Fail ",val2, val1);
  348. val1 = dist_vec_squared(vec4,vec4a);
  349. val2 =((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
  350. ensure_equals("dist_vec_squared: Fail ",val2, val1);
  351. }
  353. template<> template<>
  354. void v4math_object::test<20>()
  355. {
  356. F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, w1 = -.23f, x2 = 1.3f, y2 = 1.f, z2 = 1.f,w2 = .12f;
  357. F32 val = 2.3f,val1,val2,val3,val4;
  358. LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2);
  359. val1 = x1 + (x2 - x1)* val;
  360. val2 = y1 + (y2 - y1)* val;
  361. val3 = z1 + (z2 - z1)* val;
  362. val4 = w1 + (w2 - w1)* val;
  363. LLVector4 vec4b = lerp(vec4,vec4a,val);
  364. ensure("lerp failed", ((val1 ==vec4b.mV[VX])&& (val2 ==vec4b.mV[VY]) && (val3 ==vec4b.mV[VZ])&& (val4 ==vec4b.mV[VW])));
  365. }
  367. template<> template<>
  368. void v4math_object::test<21>()
  369. {
  370. F32 x = 1.f, y = 2.f, z = -1.1f;
  371. LLVector4 vec4(x,y,z);
  372. LLVector3 vec3 = vec4to3(vec4);
  373. ensure("vec4to3 failed", ((x == vec3.mV[VX])&& (y == vec3.mV[VY]) && (z == vec3.mV[VZ])));
  374. LLVector4 vec4a = vec3to4(vec3);
  375. ensure_equals("vec3to4 failed",vec4a,vec4);
  376. }
  378. template<> template<>
  379. void v4math_object::test<22>()
  380. {
  381. F32 x = 1.f, y = 2.f, z = -1.1f;
  382. LLVector4 vec4(x,y,z);
  383. LLSD llsd = vec4.getValue();
  384. LLVector3 vec3(llsd);
  385. LLVector4 vec4a = vec3to4(vec3);
  386. ensure_equals("getValue failed",vec4a,vec4);
  387. }
  388. }