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

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

游戏引擎

开发平台：

C++ Builder

mathmisc_test.cpp：源码内容
  1. /** 
  2.  * @file math.cpp
  3.  * @author Phoenix
  4.  * @date 2005-09-26
  5.  * @brief Tests for the llmath library.
  6.  *
  7.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2005-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 "llcrc.h"
  39. #include "llrand.h"
  40. #include "lluuid.h"
  42. #include "../llline.h"
  43. #include "../llmath.h"
  44. #include "../llsphere.h"
  45. #include "../v3math.h"
  47. namespace tut
  48. {
  49. struct math_data
  50. {
  51. };
  52. typedef test_group<math_data> math_test;
  53. typedef math_test::object math_object;
  54. tut::math_test tm("basic_linden_math");
  56. template<> template<>
  57. void math_object::test<1>()
  58. {
  59. S32 val = 89543;
  60. val = llabs(val);
  61. ensure("integer absolute value 1", (89543 == val));
  62. val = -500;
  63. val = llabs(val);
  64. ensure("integer absolute value 2", (500 == val));
  65. }
  67. template<> template<>
  68. void math_object::test<2>()
  69. {
  70. F32 val = -2583.4f;
  71. val = llabs(val);
  72. ensure("float absolute value 1", (2583.4f == val));
  73. val = 430903.f;
  74. val = llabs(val);
  75. ensure("float absolute value 2", (430903.f == val));
  76. }
  78. template<> template<>
  79. void math_object::test<3>()
  80. {
  81. F64 val = 387439393.987329839;
  82. val = llabs(val);
  83. ensure("double absolute value 1", (387439393.987329839 == val));
  84. val = -8937843.9394878;
  85. val = llabs(val);
  86. ensure("double absolute value 2", (8937843.9394878 == val));
  87. }
  89. template<> template<>
  90. void math_object::test<4>()
  91. {
  92. F32 val = 430903.9f;
  93. S32 val1 = lltrunc(val);
  94. ensure("float truncate value 1", (430903 == val1));
  95. val = -2303.9f;
  96. val1 = lltrunc(val);
  97. ensure("float truncate value 2", (-2303  == val1));
  98. }
  100. template<> template<>
  101. void math_object::test<5>()
  102. {
  103. F64 val = 387439393.987329839 ;
  104. S32 val1 = lltrunc(val);
  105. ensure("float truncate value 1", (387439393 == val1));
  106. val = -387439393.987329839;
  107. val1 = lltrunc(val);
  108. ensure("float truncate value 2", (-387439393  == val1));
  109. }
  111. template<> template<>
  112. void math_object::test<6>()
  113. {
  114. F32 val = 430903.2f;
  115. S32 val1 = llfloor(val);
  116. ensure("float llfloor value 1", (430903 == val1));
  117. val = -430903.9f;
  118. val1 = llfloor(val);
  119. ensure("float llfloor value 2", (-430904 == val1));
  120. }
  122. template<> template<>
  123. void math_object::test<7>()
  124. {
  125. F32 val = 430903.2f;
  126. S32 val1 = llceil(val);
  127. ensure("float llceil value 1", (430904 == val1));
  128. val = -430903.9f;
  129. val1 = llceil(val);
  130. ensure("float llceil value 2", (-430903 == val1));
  131. }
  133. template<> template<>
  134. void math_object::test<8>()
  135. {
  136. F32 val = 430903.2f;
  137. S32 val1 = llround(val);
  138. ensure("float llround value 1", (430903 == val1));
  139. val = -430903.9f;
  140. val1 = llround(val);
  141. ensure("float llround value 2", (-430904 == val1));
  142. }
  144. template<> template<>
  145. void math_object::test<9>()
  146. {
  147. F32 val = 430905.2654f, nearest = 100.f;
  148. val = llround(val, nearest);
  149. ensure("float llround value 1", (430900 == val));
  150. val = -430905.2654f, nearest = 10.f;
  151. val = llround(val, nearest);
  152. ensure("float llround value 1", (-430910 == val));
  153. }
  155. template<> template<>
  156. void math_object::test<10>()
  157. {
  158. F64 val = 430905.2654, nearest = 100.0;
  159. val = llround(val, nearest);
  160. ensure("double llround value 1", (430900 == val));
  161. val = -430905.2654, nearest = 10.0;
  162. val = llround(val, nearest);
  163. ensure("double llround value 1", (-430910.00000 == val));
  164. }
  166. template<> template<>
  167. void math_object::test<11>()
  168. {
  169. const F32 F_PI = 3.1415926535897932384626433832795f;
  170. F32 angle = 3506.f;
  171. angle =  llsimple_angle(angle);
  172. ensure("llsimple_angle  value 1", (angle <=F_PI && angle >= -F_PI));
  173. angle = -431.f;
  174. angle =  llsimple_angle(angle);
  175. ensure("llsimple_angle  value 1", (angle <=F_PI && angle >= -F_PI));
  176. }
  177. }
  179. namespace tut
  180. {
  181. struct uuid_data
  182. {
  183. LLUUID id;
  184. };
  185. typedef test_group<uuid_data> uuid_test;
  186. typedef uuid_test::object uuid_object;
  187. tut::uuid_test tu("uuid");
  189. template<> template<>
  190. void uuid_object::test<1>()
  191. {
  192. ensure("uuid null", id.isNull());
  193. id.generate();
  194. ensure("generate not null", id.notNull());
  195. id.setNull();
  196. ensure("set null", id.isNull());
  197. }
  199. template<> template<>
  200. void uuid_object::test<2>()
  201. {
  202. id.generate();
  203. LLUUID a(id);
  204. ensure_equals("copy equal", id, a);
  205. a.generate();
  206. ensure_not_equals("generate not equal", id, a);
  207. a = id;
  208. ensure_equals("assignment equal", id, a);
  209. }
  211. template<> template<>
  212. void uuid_object::test<3>()
  213. {
  214. id.generate();
  215. LLUUID copy(id);
  216. LLUUID mask;
  217. mask.generate();
  218. copy ^= mask;
  219. ensure_not_equals("mask not equal", id, copy);
  220. copy ^= mask;
  221. ensure_equals("mask back", id, copy);
  222. }
  224. template<> template<>
  225. void uuid_object::test<4>()
  226. {
  227. id.generate();
  228. std::string id_str = id.asString();
  229. LLUUID copy(id_str.c_str());
  230. ensure_equals("string serialization", id, copy);
  231. }
  233. }
  235. namespace tut
  236. {
  237. struct crc_data
  238. {
  239. };
  240. typedef test_group<crc_data> crc_test;
  241. typedef crc_test::object crc_object;
  242. tut::crc_test tc("crc");
  244. template<> template<>
  245. void crc_object::test<1>()
  246. {
  247. /* Test buffer update and individual char update */
  248. const char TEST_BUFFER[] = "hello &#$)$&Nd0";
  249. LLCRC c1, c2;
  250. c1.update((U8*)TEST_BUFFER, sizeof(TEST_BUFFER) - 1);
  251. char* rh = (char*)TEST_BUFFER;
  252. while(*rh != '')
  253. {
  254. c2.update(*rh);
  255. ++rh;
  256. }
  257. ensure_equals("crc update 1", c1.getCRC(), c2.getCRC());
  258. }
  260. template<> template<>
  261. void crc_object::test<2>()
  262. {
  263. /* Test mixing of buffer and individual char update */
  264. const char TEST_BUFFER1[] = "Split Buffer one $^%$%#@$";
  265. const char TEST_BUFFER2[] = "Split Buffer two )(8723#5dsds";
  266. LLCRC c1, c2;
  267. c1.update((U8*)TEST_BUFFER1, sizeof(TEST_BUFFER1) - 1);
  268. char* rh = (char*)TEST_BUFFER2;
  269. while(*rh != '')
  270. {
  271. c1.update(*rh);
  272. ++rh;
  273. }
  275. rh = (char*)TEST_BUFFER1;
  276. while(*rh != '')
  277. {
  278. c2.update(*rh);
  279. ++rh;
  280. }
  281. c2.update((U8*)TEST_BUFFER2, sizeof(TEST_BUFFER2) - 1);
  283. ensure_equals("crc update 2", c1.getCRC(), c2.getCRC());
  284. }
  285. }
  287. namespace tut
  288. {
  289. struct sphere_data
  290. {
  291. };
  292. typedef test_group<sphere_data> sphere_test;
  293. typedef sphere_test::object sphere_object;
  294. tut::sphere_test tsphere("LLSphere");
  296. template<> template<>
  297. void sphere_object::test<1>()
  298. {
  299. // test LLSphere::contains() and ::overlaps()
  300. S32 number_of_tests = 10;
  301. for (S32 test = 0; test < number_of_tests; ++test)
  302. {
  303. LLVector3 first_center(1.f, 1.f, 1.f);
  304. F32 first_radius = 3.f;
  305. LLSphere first_sphere( first_center, first_radius );
  307. F32 half_millimeter = 0.0005f;
  308. LLVector3 direction( ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
  309. direction.normalize();
  311. F32 distance = ll_frand(first_radius - 2.f * half_millimeter);
  312. LLVector3 second_center = first_center + distance * direction;
  313. F32 second_radius = first_radius - distance - half_millimeter;
  314. LLSphere second_sphere( second_center, second_radius );
  315. ensure("first sphere should contain the second", first_sphere.contains(second_sphere));
  316. ensure("first sphere should overlap the second", first_sphere.overlaps(second_sphere));
  318. distance = first_radius + ll_frand(first_radius);
  319. second_center = first_center + distance * direction;
  320. second_radius = distance - first_radius + half_millimeter;
  321. second_sphere.set( second_center, second_radius );
  322. ensure("first sphere should NOT contain the second", !first_sphere.contains(second_sphere));
  323. ensure("first sphere should overlap the second", first_sphere.overlaps(second_sphere));
  325. distance = first_radius + ll_frand(first_radius) + half_millimeter;
  326. second_center = first_center + distance * direction;
  327. second_radius = distance - first_radius - half_millimeter;
  328. second_sphere.set( second_center, second_radius );
  329. ensure("first sphere should NOT contain the second", !first_sphere.contains(second_sphere));
  330. ensure("first sphere should NOT overlap the second", !first_sphere.overlaps(second_sphere));
  331. }
  332. }
  334. template<> template<>
  335. void sphere_object::test<2>()
  336. {
  337. // test LLSphere::getBoundingSphere()
  338. S32 number_of_tests = 100;
  339. S32 number_of_spheres = 10;
  340. F32 sphere_center_range = 32.f;
  341. F32 sphere_radius_range = 5.f;
  343. for (S32 test = 0; test < number_of_tests; ++test)
  344. {
  345. // gegnerate a bunch of random sphere
  346. std::vector< LLSphere > sphere_list;
  347. for (S32 sphere_count=0; sphere_count < number_of_spheres; ++sphere_count)
  348. {
  349. LLVector3 direction( ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
  350. direction.normalize();
  351. F32 distance = ll_frand(sphere_center_range);
  352. LLVector3 center = distance * direction;
  353. F32 radius = ll_frand(sphere_radius_range);
  354. LLSphere sphere( center, radius );
  355. sphere_list.push_back(sphere);
  356. }
  358. // compute the bounding sphere
  359. LLSphere bounding_sphere = LLSphere::getBoundingSphere(sphere_list);
  361. // make sure all spheres are inside the bounding sphere
  362. {
  363. std::vector< LLSphere >::const_iterator sphere_itr;
  364. for (sphere_itr = sphere_list.begin(); sphere_itr != sphere_list.end(); ++sphere_itr)
  365. {
  366. ensure("sphere should be contained by the bounding sphere", bounding_sphere.contains(*sphere_itr));
  367. }
  368. }
  370. // TODO -- improve LLSphere::getBoundingSphere() to the point where
  371. // we can reduce the 'expansion' in the two tests below to about 
  372. // 2 mm or less
  374. F32 expansion = 0.005f;
  375. // move all spheres out a little bit 
  376. // and count how many are NOT contained
  377. {
  378. std::vector< LLVector3 > uncontained_directions;
  379. std::vector< LLSphere >::iterator sphere_itr;
  380. for (sphere_itr = sphere_list.begin(); sphere_itr != sphere_list.end(); ++sphere_itr)
  381. {
  382. LLVector3 direction = sphere_itr->getCenter() - bounding_sphere.getCenter();
  383. direction.normalize();
  385. sphere_itr->setCenter( sphere_itr->getCenter() + expansion * direction );
  386. if (! bounding_sphere.contains( *sphere_itr ) )
  387. {
  388. uncontained_directions.push_back(direction);
  389. }
  390. }
  391. ensure("when moving spheres out there should be at least two uncontained spheres", 
  392. uncontained_directions.size() > 1);
  394. /* TODO -- when the bounding sphere algorithm is improved we can open up this test
  395.  * at the moment it occasionally fails when the sphere collection is tight and small
  396.  * (2 meters or less)
  397. if (2 == uncontained_directions.size() )
  398. {
  399. // if there were only two uncontained spheres then
  400. // the two directions should be nearly opposite
  401. F32 dir_dot = uncontained_directions[0] * uncontained_directions[1];
  402. ensure("two uncontained spheres should lie opposite the bounding center", dir_dot < -0.95f);
  403. }
  404. */
  405. }
  407. // compute the new bounding sphere
  408. bounding_sphere = LLSphere::getBoundingSphere(sphere_list);
  410. // increase the size of all spheres a little bit
  411. // and count how many are NOT contained
  412. {
  413. std::vector< LLVector3 > uncontained_directions;
  414. std::vector< LLSphere >::iterator sphere_itr;
  415. for (sphere_itr = sphere_list.begin(); sphere_itr != sphere_list.end(); ++sphere_itr)
  416. {
  417. LLVector3 direction = sphere_itr->getCenter() - bounding_sphere.getCenter();
  418. direction.normalize();
  420. sphere_itr->setRadius( sphere_itr->getRadius() + expansion );
  421. if (! bounding_sphere.contains( *sphere_itr ) )
  422. {
  423. uncontained_directions.push_back(direction);
  424. }
  425. }
  426. ensure("when boosting sphere radii there should be at least two uncontained spheres", 
  427. uncontained_directions.size() > 1);
  429. /* TODO -- when the bounding sphere algorithm is improved we can open up this test
  430.  * at the moment it occasionally fails when the sphere collection is tight and small
  431.  * (2 meters or less)
  432. if (2 == uncontained_directions.size() )
  433. {
  434. // if there were only two uncontained spheres then
  435. // the two directions should be nearly opposite
  436. F32 dir_dot = uncontained_directions[0] * uncontained_directions[1];
  437. ensure("two uncontained spheres should lie opposite the bounding center", dir_dot < -0.95f);
  438. }
  439. */
  440. }
  441. }
  442. }
  443. }
  445. namespace tut
  446. {
  447. F32 SMALL_RADIUS = 1.0f;
  448. F32 MEDIUM_RADIUS = 5.0f;
  449. F32 LARGE_RADIUS = 10.0f;
  451. struct line_data
  452. {
  453. };
  454. typedef test_group<line_data> line_test;
  455. typedef line_test::object line_object;
  456. tut::line_test tline("LLLine");
  458. template<> template<>
  459. void line_object::test<1>()
  460. {
  461. // this is a test for LLLine::intersects(point) which returns TRUE 
  462. // if the line passes within some tolerance of point
  464. // these tests will have some floating point error, 
  465. // so we need to specify how much error is ok
  466. F32 allowable_relative_error = 0.00001f;
  467. S32 number_of_tests = 100;
  468. for (S32 test = 0; test < number_of_tests; ++test)
  469. {
  470. // generate some random point to be on the line
  471. LLVector3 point_on_line( ll_frand(2.f) - 1.f, 
  472.      ll_frand(2.f) - 1.f, 
  473.      ll_frand(2.f) - 1.f);
  474. point_on_line.normalize();
  475. point_on_line *= ll_frand(LARGE_RADIUS);
  477. // generate some random point to "intersect"
  478. LLVector3 random_direction ( ll_frand(2.f) - 1.f, 
  479.      ll_frand(2.f) - 1.f, 
  480.      ll_frand(2.f) - 1.f);
  481. random_direction.normalize();
  483. LLVector3 random_offset( ll_frand(2.f) - 1.f, 
  484.      ll_frand(2.f) - 1.f, 
  485.      ll_frand(2.f) - 1.f);
  486. random_offset.normalize();
  487. random_offset *= ll_frand(SMALL_RADIUS);
  489. LLVector3 point = point_on_line + MEDIUM_RADIUS * random_direction
  490. + random_offset;
  492. // compute the axis of approach (a unit vector between the points)
  493. LLVector3 axis_of_approach = point - point_on_line;
  494. axis_of_approach.normalize();
  496. // compute the direction of the the first line (perp to axis_of_approach)
  497. LLVector3 first_dir( ll_frand(2.f) - 1.f, 
  498.      ll_frand(2.f) - 1.f, 
  499.      ll_frand(2.f) - 1.f);
  500. first_dir.normalize();
  501. F32 dot = first_dir * axis_of_approach;
  502. first_dir -= dot * axis_of_approach; // subtract component parallel to axis
  503. first_dir.normalize();
  505. // construct the line
  506. LLVector3 another_point_on_line = point_on_line + ll_frand(LARGE_RADIUS) * first_dir;
  507. LLLine line(another_point_on_line, point_on_line);
  509. // test that the intersection point is within MEDIUM_RADIUS + SMALL_RADIUS
  510. F32 test_radius = MEDIUM_RADIUS + SMALL_RADIUS;
  511. test_radius += (LARGE_RADIUS * allowable_relative_error);
  512. ensure("line should pass near intersection point", line.intersects(point, test_radius));
  514. test_radius = allowable_relative_error * (point - point_on_line).length();
  515. ensure("line should intersect point used to define it", line.intersects(point_on_line, test_radius));
  516. }
  517. }
  519. template<> template<>
  520. void line_object::test<2>()
  521. {
  522.           /*
  523.             These tests fail intermittently on all platforms - see DEV-16600
  524.             Commenting this out until dev has time to investigate.
  525.             
  526. // this is a test for LLLine::nearestApproach(LLLIne) method
  527. // which computes the point on a line nearest another line
  529. // these tests will have some floating point error, 
  530. // so we need to specify how much error is ok
  531. // TODO -- make nearestApproach() algorithm more accurate so
  532. // we can tighten the allowable_error.  Most tests are tighter
  533. // than one milimeter, however when doing randomized testing
  534. // you can walk into inaccurate cases.
  535. F32 allowable_relative_error = 0.001f;
  536. S32 number_of_tests = 100;
  537. for (S32 test = 0; test < number_of_tests; ++test)
  538. {
  539. // generate two points to be our known nearest approaches
  540. LLVector3 some_point( ll_frand(2.f) - 1.f, 
  541.       ll_frand(2.f) - 1.f, 
  542.       ll_frand(2.f) - 1.f);
  543. some_point.normalize();
  544. some_point *= ll_frand(LARGE_RADIUS);
  546. LLVector3 another_point( ll_frand(2.f) - 1.f, 
  547.      ll_frand(2.f) - 1.f, 
  548.      ll_frand(2.f) - 1.f);
  549. another_point.normalize();
  550. another_point *= ll_frand(LARGE_RADIUS);
  552. // compute the axis of approach (a unit vector between the points)
  553. LLVector3 axis_of_approach = another_point - some_point;
  554. axis_of_approach.normalize();
  556. // compute the direction of the the first line (perp to axis_of_approach)
  557. LLVector3 first_dir( ll_frand(2.f) - 1.f, 
  558.      ll_frand(2.f) - 1.f, 
  559.      ll_frand(2.f) - 1.f);
  560. F32 dot = first_dir * axis_of_approach;
  561. first_dir -= dot * axis_of_approach; // subtract component parallel to axis
  562. first_dir.normalize(); // normalize
  564. // compute the direction of the the second line
  565. LLVector3 second_dir( ll_frand(2.f) - 1.f, 
  566.       ll_frand(2.f) - 1.f, 
  567.       ll_frand(2.f) - 1.f);
  568. dot = second_dir * axis_of_approach;
  569. second_dir -= dot * axis_of_approach;
  570. second_dir.normalize();
  572. // make sure the lines aren't too parallel, 
  573. dot = fabsf(first_dir * second_dir);
  574. if (dot > 0.99f)
  575. {
  576. // skip this test, we're not interested in testing 
  577. // the intractible cases
  578. continue;
  579. }
  581. // construct the lines
  582. LLVector3 first_point = some_point + ll_frand(LARGE_RADIUS) * first_dir;
  583. LLLine first_line(first_point, some_point);
  585. LLVector3 second_point = another_point + ll_frand(LARGE_RADIUS) * second_dir;
  586. LLLine second_line(second_point, another_point);
  588. // compute the points of nearest approach
  589. LLVector3 some_computed_point = first_line.nearestApproach(second_line);
  590. LLVector3 another_computed_point = second_line.nearestApproach(first_line);
  592. // compute the error
  593. F32 first_error = (some_point - some_computed_point).length();
  594. F32 scale = llmax((some_point - another_point).length(), some_point.length());
  595. scale = llmax(scale, another_point.length());
  596. scale = llmax(scale, 1.f);
  597. F32 first_relative_error = first_error / scale;
  599. F32 second_error = (another_point - another_computed_point).length();
  600. F32 second_relative_error = second_error / scale;
  602. //if (first_relative_error > allowable_relative_error)
  603. //{
  604. // std::cout << "first_error = " << first_error 
  605. // << "  first_relative_error = " << first_relative_error 
  606. // << "  scale = " << scale 
  607. // << "  dir_dot = " << (first_dir * second_dir)
  608. // << std::endl;
  609. //}
  610. //if (second_relative_error > allowable_relative_error)
  611. //{
  612. // std::cout << "second_error = " << second_error 
  613. // << "  second_relative_error = " << second_relative_error 
  614. // << "  scale = " << scale 
  615. // << "  dist = " << (some_point - another_point).length()
  616. // << "  dir_dot = " << (first_dir * second_dir)
  617. // << std::endl;
  618. //}
  620. // test that the errors are small
  622. ensure("first line should accurately compute its closest approach", 
  623. first_relative_error <= allowable_relative_error);
  624. ensure("second line should accurately compute its closest approach", 
  625. second_relative_error <= allowable_relative_error);
  626. }
  627.           */
  628. }
  630. F32 ALMOST_PARALLEL = 0.99f;
  631. template<> template<>
  632. void line_object::test<3>()
  633. {
  634. // this is a test for LLLine::getIntersectionBetweenTwoPlanes() method
  636. // first some known tests
  637. LLLine xy_plane(LLVector3(0.f, 0.f, 2.f), LLVector3(0.f, 0.f, 3.f));
  638. LLLine yz_plane(LLVector3(2.f, 0.f, 0.f), LLVector3(3.f, 0.f, 0.f));
  639. LLLine zx_plane(LLVector3(0.f, 2.f, 0.f), LLVector3(0.f, 3.f, 0.f));
  641. LLLine x_line;
  642. LLLine y_line;
  643. LLLine z_line;
  645. bool x_success = LLLine::getIntersectionBetweenTwoPlanes(x_line, xy_plane, zx_plane);
  646. bool y_success = LLLine::getIntersectionBetweenTwoPlanes(y_line, yz_plane, xy_plane);
  647. bool z_success = LLLine::getIntersectionBetweenTwoPlanes(z_line, zx_plane, yz_plane);
  649. ensure("xy and zx planes should intersect", x_success);
  650. ensure("yz and xy planes should intersect", y_success);
  651. ensure("zx and yz planes should intersect", z_success);
  653. LLVector3 direction = x_line.getDirection();
  654. ensure("x_line should be parallel to x_axis", fabs(direction.mV[VX]) == 1.f
  655.                                       && 0.f == direction.mV[VY]
  656.                                       && 0.f == direction.mV[VZ] );
  657. direction = y_line.getDirection();
  658. ensure("y_line should be parallel to y_axis", 0.f == direction.mV[VX]
  659.   && fabs(direction.mV[VY]) == 1.f
  660.                                       && 0.f == direction.mV[VZ] );
  661. direction = z_line.getDirection();
  662. ensure("z_line should be parallel to z_axis", 0.f == direction.mV[VX]
  663.                                       && 0.f == direction.mV[VY]
  664.   && fabs(direction.mV[VZ]) == 1.f );
  666. // next some random tests
  667. F32 allowable_relative_error = 0.0001f;
  668. S32 number_of_tests = 20;
  669. for (S32 test = 0; test < number_of_tests; ++test)
  670. {
  671. // generate the known line
  672. LLVector3 some_point( ll_frand(2.f) - 1.f, 
  673.       ll_frand(2.f) - 1.f, 
  674.       ll_frand(2.f) - 1.f);
  675. some_point.normalize();
  676. some_point *= ll_frand(LARGE_RADIUS);
  677. LLVector3 another_point( ll_frand(2.f) - 1.f, 
  678.      ll_frand(2.f) - 1.f, 
  679.      ll_frand(2.f) - 1.f);
  680. another_point.normalize();
  681. another_point *= ll_frand(LARGE_RADIUS);
  682. LLLine known_intersection(some_point, another_point);
  684. // compute a plane that intersect the line
  685. LLVector3 point_on_plane( ll_frand(2.f) - 1.f, 
  686.       ll_frand(2.f) - 1.f, 
  687.       ll_frand(2.f) - 1.f);
  688. point_on_plane.normalize();
  689. point_on_plane *= ll_frand(LARGE_RADIUS);
  690. LLVector3 plane_normal = (point_on_plane - some_point) % known_intersection.getDirection();
  691. plane_normal.normalize();
  692. LLLine first_plane(point_on_plane, point_on_plane + plane_normal);
  694. // compute a different plane that intersect the line
  695. LLVector3 point_on_different_plane( ll_frand(2.f) - 1.f, 
  696.     ll_frand(2.f) - 1.f, 
  697.     ll_frand(2.f) - 1.f);
  698. point_on_different_plane.normalize();
  699. point_on_different_plane *= ll_frand(LARGE_RADIUS);
  700. LLVector3 different_plane_normal = (point_on_different_plane - another_point) % known_intersection.getDirection();
  701. different_plane_normal.normalize();
  702. LLLine second_plane(point_on_different_plane, point_on_different_plane + different_plane_normal);
  704. if (fabs(plane_normal * different_plane_normal) > ALMOST_PARALLEL)
  705. {
  706. // the two planes are approximately parallel, so we won't test this case
  707. continue;
  708. }
  710. LLLine measured_intersection;
  711. bool success = LLLine::getIntersectionBetweenTwoPlanes(
  712. measured_intersection,
  713. first_plane,
  714. second_plane);
  716. ensure("plane intersection should succeed", success);
  718. F32 dot = fabs(known_intersection.getDirection() * measured_intersection.getDirection());
  719. ensure("measured intersection should be parallel to known intersection",
  720. dot > ALMOST_PARALLEL);
  722. ensure("measured intersection should pass near known point",
  723. measured_intersection.intersects(some_point, LARGE_RADIUS * allowable_relative_error));
  724. }
  725. }
  726. }