lolengine
/
lol
zrcadlo https://github.com/lolengine/lol
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
2374 Revize
5 Větve
35 MiB
 
 
 
Strom: 3916a44c58
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „3916a44c58“
${ noResults }
lol/src/t/math/quat.cpp

541 řádky
18 KiB
Surový Blame Historie 

  1. //

  2. // Lol Engine

  3. //

  4. // Copyright: (c) 2010-2014 Sam Hocevar <sam@hocevar.net>

  5. //   This program is free software; you can redistribute it and/or

  6. //   modify it under the terms of the Do What The Fuck You Want To

  7. //   Public License, Version 2, as published by Sam Hocevar. See

  8. //   http://www.wtfpl.net/ for more details.

  9. //

  10. 

  11. #include <lol/engine-internal.h>

  12. 

  13. #include <lolunit.h>

  14. 

  15. namespace lol

  16. {

  17. 

  18. lolunit_declare_fixture(QuaternionTest)

  19. {

  20.     void SetUp()

  21.     {

  22.         /* Generate identity quaternions */

  23.         m_vectorpairs.Push(vec3::axis_x, vec3::axis_x);

  24.         m_vectorpairs.Push(2.f * vec3::axis_x, 3.f * vec3::axis_x);

  25. 

  26.         /* Generate 90-degree rotations */

  27.         m_vectorpairs.Push(vec3::axis_x, vec3::axis_y);

  28.         m_vectorpairs.Push(2.f * vec3::axis_x, 3.f * vec3::axis_y);

  29. 

  30.         /* Generate 180-degree rotations */

  31.         m_vectorpairs.Push(vec3::axis_x, -vec3::axis_x);

  32.         m_vectorpairs.Push(2.f * vec3::axis_x, -3.f * vec3::axis_x);

  33. 

  34.         /* Fill array with random test values */

  35.         for (int i = 0; i < 10000; ++i)

  36.         {

  37.             vec3 v1 = lol::pow(10.f, rand(-5.f, 5.f))

  38.                     * vec3(rand(-1.f, 1.f), rand(-1.f, 1.f), rand(-1.f, 1.f));

  39.             vec3 v2 = lol::pow(10.f, rand(-5.f, 5.f))

  40.                     * vec3(rand(-1.f, 1.f), rand(-1.f, 1.f), rand(-1.f, 1.f));

  41.             m_vectorpairs.Push(v1, v2);

  42.         }

  43.     }

  44. 

  45.     void TearDown() {}

  46. 

  47.     lolunit_declare_test(Equality)

  48.     {

  49.         quat a4(1.f, 2.f, 3.f, 4.f);

  50.         quat b4(0.f, 2.f, 3.f, 4.f);

  51.         quat c4(1.f, 0.f, 3.f, 4.f);

  52.         quat d4(1.f, 2.f, 0.f, 4.f);

  53.         quat e4(1.f, 2.f, 3.f, 0.f);

  54. 

  55.         lolunit_assert_equal(a4, a4);

  56.         lolunit_assert_not_different(a4, a4);

  57. 

  58.         lolunit_assert_different(a4, b4);

  59.         lolunit_assert_not_equal(a4, b4);

  60.         lolunit_assert_different(a4, c4);

  61.         lolunit_assert_not_equal(a4, c4);

  62.         lolunit_assert_different(a4, d4);

  63.         lolunit_assert_not_equal(a4, d4);

  64.         lolunit_assert_different(a4, e4);

  65.         lolunit_assert_not_equal(a4, e4);

  66.     }

  67. 

  68.     lolunit_declare_test(UnaryMinus)

  69.     {

  70.         quat a(1.f, 3.f, 2.f, 4.f);

  71.         quat b(-1.f, -3.f, -2.f, -4.f);

  72. 

  73.         lolunit_assert_equal(a, -b);

  74.         lolunit_assert_equal(-a, b);

  75.     }

  76. 

  77.     lolunit_declare_test(Conjugate)

  78.     {

  79.         quat a(1.f, 3.f, 2.f, 4.f);

  80.         quat b(1.f, -3.f, -2.f, -4.f);

  81. 

  82.         lolunit_assert_equal(a, ~b);

  83.         lolunit_assert_equal(~a, b);

  84.     }

  85. 

  86.     lolunit_declare_test(Norm)

  87.     {

  88.         quat a(2.f, -2.f, -8.f, 3.f);

  89. 

  90.         lolunit_assert_equal(norm(a), 9.f);

  91. 

  92.         quat b = a * ~a;

  93.         quat c(norm(a) * norm(a), 0.f, 0.f, 0.f);

  94. 

  95.         lolunit_assert_equal(b, c);

  96. 

  97.         quat d(2.f, 5.f, -4.f, -2.f);

  98. 

  99.         lolunit_assert_equal(norm(a * d), norm(a) * norm(d));

  100.     }

  101. 

  102.     lolunit_declare_test(Dot)

  103.     {

  104.         quat a(-1.f, 2.f, -3.f, 4.f);

  105.         quat b(8.f, 7.f, 6.f, 5.f);

  106. 

  107.         lolunit_assert_equal(dot(a, b), 8.f);

  108.     }

  109. 

  110.     lolunit_declare_test(Base)

  111.     {

  112.         quat one(1.f, 0.f, 0.f, 0.f);

  113.         quat i(0.f, 1.f, 0.f, 0.f);

  114.         quat j(0.f, 0.f, 1.f, 0.f);

  115.         quat k(0.f, 0.f, 0.f, 1.f);

  116. 

  117.         lolunit_assert_equal(norm(one), 1.f);

  118.         lolunit_assert_equal(norm(i), 1.f);

  119.         lolunit_assert_equal(norm(j), 1.f);

  120.         lolunit_assert_equal(norm(k), 1.f);

  121. 

  122.         lolunit_assert_equal(i * i, -one);

  123.         lolunit_assert_equal(j * j, -one);

  124.         lolunit_assert_equal(k * k, -one);

  125.         lolunit_assert_equal(i * j * k, -one);

  126. 

  127.         lolunit_assert_equal(i * j, k);

  128.         lolunit_assert_equal(j * i, -k);

  129.         lolunit_assert_equal(j * k, i);

  130.         lolunit_assert_equal(k * j, -i);

  131.         lolunit_assert_equal(k * i, j);

  132.         lolunit_assert_equal(i * k, -j);

  133.     }

  134. 

  135.     lolunit_declare_test(Normalize)

  136.     {

  137.         quat a(2.f, -2.f, -8.f, 3.f);

  138.         quat b = normalize(a);

  139. 

  140.         lolunit_assert_doubles_equal(norm(b), 1.0, 1e-5);

  141.     }

  142. 

  143.     lolunit_declare_test(Reciprocal)

  144.     {

  145.         quat a(2.f, -2.f, -8.f, 3.f);

  146.         quat b = re(a);

  147.         quat c = 1.f / a;

  148. 

  149.         lolunit_assert_doubles_equal(b.w, c.w, 1e-5);

  150.         lolunit_assert_doubles_equal(b.x, c.x, 1e-5);

  151.         lolunit_assert_doubles_equal(b.y, c.y, 1e-5);

  152.         lolunit_assert_doubles_equal(b.z, c.z, 1e-5);

  153. 

  154.         quat m1 = a * b;

  155.         quat m2 = b * a;

  156.         lolunit_assert_doubles_equal(m1.w, m2.w, 1e-5);

  157.         lolunit_assert_doubles_equal(m1.x, m2.x, 1e-5);

  158.         lolunit_assert_doubles_equal(m1.y, m2.y, 1e-5);

  159.         lolunit_assert_doubles_equal(m1.z, m2.z, 1e-5);

  160. 

  161.         lolunit_assert_doubles_equal(m1.w, 1.0, 1e-5);

  162.         lolunit_assert_doubles_equal(m1.x, 0.0, 1e-5);

  163.         lolunit_assert_doubles_equal(m1.y, 0.0, 1e-5);

  164.         lolunit_assert_doubles_equal(m1.z, 0.0, 1e-5);

  165.     }

  166. 

  167.     lolunit_declare_test(Rotation)

  168.     {

  169.         /* Check that rotating 10 degrees twice means rotating 20 degrees */

  170.         quat a = quat::rotate(10.f, vec3::axis_x);

  171.         quat b = quat::rotate(20.f, vec3::axis_x);

  172.         quat c = a * a;

  173. 

  174.         lolunit_assert_doubles_equal(c.w, b.w, 1e-5);

  175.         lolunit_assert_doubles_equal(c.x, b.x, 1e-5);

  176.         lolunit_assert_doubles_equal(c.y, b.y, 1e-5);

  177.         lolunit_assert_doubles_equal(c.z, b.z, 1e-5);

  178. 

  179.         /* Check that rotating 10 degrees then 20 is the same as 20 then 10 */

  180.         quat d = a * b;

  181.         quat e = b * a;

  182. 

  183.         lolunit_assert_doubles_equal(e.w, d.w, 1e-5);

  184.         lolunit_assert_doubles_equal(e.x, d.x, 1e-5);

  185.         lolunit_assert_doubles_equal(e.y, d.y, 1e-5);

  186.         lolunit_assert_doubles_equal(e.z, d.z, 1e-5);

  187.     }

  188. 

  189.     lolunit_declare_test(ToAxisAngle)

  190.     {

  191.         quat q = quat::rotate(10.f, vec3::axis_x);

  192.         vec3 axis = q.axis();

  193.         float angle = q.angle();

  194. 

  195.         lolunit_assert_doubles_equal(1.0, axis.x, 1e-6);

  196.         lolunit_assert_doubles_equal(0.0, axis.y, 1e-6);

  197.         lolunit_assert_doubles_equal(0.0, axis.z, 1e-6);

  198. 

  199.         lolunit_assert_doubles_equal(10.0, (double)degrees(angle), 1e-6);

  200.     }

  201. 

  202.     lolunit_declare_test(FromTwoVectors)

  203.     {

  204.         for (auto pair : m_vectorpairs)

  205.         {

  206.             vec3 a = pair.m1;

  207.             vec3 b = pair.m2;

  208.             vec3 da = normalize(a);

  209.             vec3 db = normalize(b);

  210. 

  211.             quat q = quat::rotate(a, b);

  212. 

  213.             /* Check that q is a unit quaternion */

  214.             lolunit_assert_doubles_equal(1.0, (double)norm(q), 1e-5);

  215. 

  216.             /* Check that q transforms da into db */

  217.             vec3 c = q.transform(da);

  218. 

  219.             lolunit_assert_doubles_equal(c.x, db.x, 1e-5);

  220.             lolunit_assert_doubles_equal(c.y, db.y, 1e-5);

  221.             lolunit_assert_doubles_equal(c.z, db.z, 1e-5);

  222. 

  223.             /* Check that ~q transforms db into da */

  224.             vec3 d = (~q).transform(db);

  225. 

  226.             lolunit_assert_doubles_equal(d.x, da.x, 1e-5);

  227.             lolunit_assert_doubles_equal(d.y, da.y, 1e-5);

  228.             lolunit_assert_doubles_equal(d.z, da.z, 1e-5);

  229. 

  230.             if (distance(da, db) > 1e-6f)

  231.             {

  232.                 /* If da and db differ, check that the rotation axis is normal to both

  233.                  * vectors, which is only true if the rotation uses the shortest path. */

  234.                 vec3 axis = q.axis();

  235.                 lolunit_assert_doubles_equal(0.0, (double)dot(axis, da), 1e-5);

  236.                 lolunit_assert_doubles_equal(0.0, (double)dot(axis, db), 1e-5);

  237.             }

  238.             else

  239.             {

  240.                 /* If da and db are roughly the same, check that the rotation angle

  241.                  * is zero. */

  242.                 lolunit_assert_doubles_equal(0.0, (double)q.angle(), 1e-5);

  243.             }

  244.         }

  245.     }

  246. 

  247.     lolunit_declare_test(FromEulerNorm)

  248.     {

  249.         for (int i = 0; i < 100; ++i)

  250.         {

  251.             vec3 angles(rand(360.f), rand(360.f), rand(360.f));

  252. 

  253.             /* Tait-Bryan */

  254.             quat q1 = quat::fromeuler_xyz(angles);

  255.             lolunit_assert_doubles_equal(norm(q1), 1.f, 1e-5);

  256. 

  257.             quat q2 = quat::fromeuler_yzx(angles);

  258.             lolunit_assert_doubles_equal(norm(q2), 1.f, 1e-5);

  259. 

  260.             quat q3 = quat::fromeuler_zxy(angles);

  261.             lolunit_assert_doubles_equal(norm(q3), 1.f, 1e-5);

  262. 

  263.             quat q4 = quat::fromeuler_xzy(angles);

  264.             lolunit_assert_doubles_equal(norm(q4), 1.f, 1e-5);

  265. 

  266.             quat q5 = quat::fromeuler_zyx(angles);

  267.             lolunit_assert_doubles_equal(norm(q5), 1.f, 1e-5);

  268. 

  269.             quat q6 = quat::fromeuler_yxz(angles);

  270.             lolunit_assert_doubles_equal(norm(q6), 1.f, 1e-5);

  271. 

  272.             /* Euler */

  273.             quat q7 = quat::fromeuler_xyx(angles);

  274.             lolunit_assert_doubles_equal(norm(q7), 1.f, 1e-5);

  275. 

  276.             quat q8 = quat::fromeuler_yzy(angles);

  277.             lolunit_assert_doubles_equal(norm(q8), 1.f, 1e-5);

  278. 

  279.             quat q9 = quat::fromeuler_zxz(angles);

  280.             lolunit_assert_doubles_equal(norm(q9), 1.f, 1e-5);

  281. 

  282.             quat q10 = quat::fromeuler_xzx(angles);

  283.             lolunit_assert_doubles_equal(norm(q10), 1.f, 1e-5);

  284. 

  285.             quat q11 = quat::fromeuler_zyz(angles);

  286.             lolunit_assert_doubles_equal(norm(q11), 1.f, 1e-5);

  287. 

  288.             quat q12 = quat::fromeuler_yxy(angles);

  289.             lolunit_assert_doubles_equal(norm(q12), 1.f, 1e-5);

  290.         }

  291.     }

  292. 

  293.     lolunit_declare_test(FirstTwoEulerAngles)

  294.     {

  295.         for (int i = 0; i < 100; ++i)

  296.         {

  297.             /* We check that fromeuler_xyx and fromeuler_xyz give the

  298.              * same result if the 3rd angle is zero. */

  299.             vec3 angles(rand(360.f), rand(360.f), 0.f);

  300.             quat q1, q2;

  301. 

  302.             q1 = quat::fromeuler_xyz(angles);

  303.             q2 = quat::fromeuler_xyx(angles);

  304. 

  305.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  306.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  307.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  308.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  309. 

  310.             q1 = quat::fromeuler_yzx(angles);

  311.             q2 = quat::fromeuler_yzy(angles);

  312. 

  313.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  314.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  315.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  316.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  317. 

  318.             q1 = quat::fromeuler_zxy(angles);

  319.             q2 = quat::fromeuler_zxz(angles);

  320. 

  321.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  322.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  323.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  324.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  325. 

  326.             q1 = quat::fromeuler_xzy(angles);

  327.             q2 = quat::fromeuler_xzx(angles);

  328. 

  329.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  330.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  331.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  332.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  333. 

  334.             q1 = quat::fromeuler_zyx(angles);

  335.             q2 = quat::fromeuler_zyz(angles);

  336. 

  337.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  338.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  339.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  340.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  341. 

  342.             q1 = quat::fromeuler_yxz(angles);

  343.             q2 = quat::fromeuler_yxy(angles);

  344. 

  345.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  346.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  347.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  348.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  349.         }

  350.     }

  351. 

  352.     lolunit_declare_test(LastTwoEulerAngles)

  353.     {

  354.         for (int i = 0; i < 100; ++i)

  355.         {

  356.             /* We check that fromeuler_zyz and fromeuler_xyz give the

  357.              * same result if the 1st angle is zero. */

  358.             vec3 angles(0.f, rand(360.f), rand(360.f));

  359.             quat q1, q2;

  360. 

  361.             q1 = quat::fromeuler_xyz(angles);

  362.             q2 = quat::fromeuler_zyz(angles);

  363. 

  364.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  365.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  366.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  367.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  368. 

  369.             q1 = quat::fromeuler_yzx(angles);

  370.             q2 = quat::fromeuler_xzx(angles);

  371. 

  372.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  373.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  374.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  375.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  376. 

  377.             q1 = quat::fromeuler_zxy(angles);

  378.             q2 = quat::fromeuler_yxy(angles);

  379. 

  380.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  381.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  382.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  383.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  384. 

  385.             q1 = quat::fromeuler_xzy(angles);

  386.             q2 = quat::fromeuler_yzy(angles);

  387. 

  388.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  389.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  390.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  391.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  392. 

  393.             q1 = quat::fromeuler_zyx(angles);

  394.             q2 = quat::fromeuler_xyx(angles);

  395. 

  396.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  397.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  398.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  399.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  400. 

  401.             q1 = quat::fromeuler_yxz(angles);

  402.             q2 = quat::fromeuler_zxz(angles);

  403. 

  404.             lolunit_assert_doubles_equal(q1.w, q2.w, 1e-5);

  405.             lolunit_assert_doubles_equal(q1.x, q2.x, 1e-5);

  406.             lolunit_assert_doubles_equal(q1.y, q2.y, 1e-5);

  407.             lolunit_assert_doubles_equal(q1.z, q2.z, 1e-5);

  408.         }

  409.     }

  410. 

  411.     lolunit_declare_test(TaitBryanAngles)

  412.     {

  413.         for (int i = 0; i < 100; ++i)

  414.         {

  415.             /* Pick a random point and a random quaternion. We want

  416.              * to check whether going to Tait-Bryan angles and back to

  417.              * quaternion creates the same transform. */

  418.             vec3 p(rand(1.f, 2.f), rand(1.f, 2.f), rand(1.f, 2.f));

  419.             quat q0 = normalize(quat(rand(-1.f, 1.f), rand(-1.f, 1.f),

  420.                                      rand(-1.f, 1.f), rand(-1.f, 1.f)));

  421.             vec3 p0 = q0.transform(p);

  422. 

  423.             /* x-y-z */

  424.             quat q1 = quat::fromeuler_xyz(vec3::toeuler_xyz(q0));

  425.             vec3 p1 = q1.transform(p);

  426. 

  427.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  428.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  429.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  430. 

  431.             /* y-z-x */

  432.             q1 = quat::fromeuler_yzx(vec3::toeuler_yzx(q0));

  433.             p1 = q1.transform(p);

  434. 

  435.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  436.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  437.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  438. 

  439.             /* z-x-y */

  440.             q1 = quat::fromeuler_zxy(vec3::toeuler_zxy(q0));

  441.             p1 = q1.transform(p);

  442. 

  443.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  444.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  445.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  446. 

  447.             /* x-z-y */

  448.             q1 = quat::fromeuler_xzy(vec3::toeuler_xzy(q0));

  449.             p1 = q1.transform(p);

  450. 

  451.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  452.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  453.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  454. 

  455.             /* z-y-x */

  456.             q1 = quat::fromeuler_zyx(vec3::toeuler_zyx(q0));

  457.             p1 = q1.transform(p);

  458. 

  459.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  460.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  461.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  462. 

  463.             /* y-x-z */

  464.             q1 = quat::fromeuler_yxz(vec3::toeuler_yxz(q0));

  465.             p1 = q1.transform(p);

  466. 

  467.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  468.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  469.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  470.         }

  471.     }

  472. 

  473.     lolunit_declare_test(EulerAngles)

  474.     {

  475.         for (int i = 0; i < 100; ++i)

  476.         {

  477.             /* Pick a random point and a random quaternion. We want

  478.              * to check whether going to Euler angles and back to

  479.              * quaternion creates the same transform. */

  480.             vec3 p(rand(1.f, 2.f), rand(1.f, 2.f), rand(1.f, 2.f));

  481.             quat q0 = normalize(quat(rand(-1.f, 1.f), rand(-1.f, 1.f),

  482.                                      rand(-1.f, 1.f), rand(-1.f, 1.f)));

  483.             vec3 p0 = q0.transform(p);

  484. 

  485.             /* x-y-x */

  486.             quat q1 = quat::fromeuler_xyx(vec3::toeuler_xyx(q0));

  487.             vec3 p1 = q1.transform(p);

  488. 

  489.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  490.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  491.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  492. 

  493.             /* y-z-y */

  494.             q1 = quat::fromeuler_yzy(vec3::toeuler_yzy(q0));

  495.             p1 = q1.transform(p);

  496. 

  497.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  498.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  499.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  500. 

  501.             /* z-x-z */

  502.             q1 = quat::fromeuler_zxz(vec3::toeuler_zxz(q0));

  503.             p1 = q1.transform(p);

  504. 

  505.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  506.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  507.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  508. 

  509.             /* x-z-x */

  510.             q1 = quat::fromeuler_xzx(vec3::toeuler_xzx(q0));

  511.             p1 = q1.transform(p);

  512. 

  513.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  514.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  515.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  516. 

  517.             /* z-y-z */

  518.             q1 = quat::fromeuler_zyz(vec3::toeuler_zyz(q0));

  519.             p1 = q1.transform(p);

  520. 

  521.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  522.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  523.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  524. 

  525.             /* y-x-y */

  526.             q1 = quat::fromeuler_yxy(vec3::toeuler_yxy(q0));

  527.             p1 = q1.transform(p);

  528. 

  529.             lolunit_assert_doubles_equal(p1.x, p0.x, 1e-4);

  530.             lolunit_assert_doubles_equal(p1.y, p0.y, 1e-4);

  531.             lolunit_assert_doubles_equal(p1.z, p0.z, 1e-4);

  532.         }

  533.     }

  534. 

  535. private:

  536.     array<vec3, vec3> m_vectorpairs;

  537. };

  538. 

  539. } /* namespace lol */