lolengine
/
lol
kopie van https://github.com/lolengine/lol
1
0
Vork 0
Code Kwesties 0 Publicaties 0 Wiki Activiteit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1932 Commits
5 Branches
601 MiB
 
 
 
Tree: 568acece6e
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van '568acece6e'
${ noResults }
lol/test/unit/quat.cpp

483 regels
16 KiB
Ruw Blame Geschiedenis 

  1. //

  2. // Lol Engine

  3. //

  4. // Copyright: (c) 2010-2013 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. #if defined HAVE_CONFIG_H

  12. #   include "config.h"

  13. #endif

  14. 

  15. #include "core.h"

  16. #include "lol/unit.h"

  17. 

  18. namespace lol

  19. {

  20. 

  21. LOLUNIT_FIXTURE(QuaternionTest)

  22. {

  23.     void SetUp() {}

  24. 

  25.     void TearDown() {}

  26. 

  27.     LOLUNIT_TEST(Equality)

  28.     {

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

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

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

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

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

  34. 

  35.         LOLUNIT_ASSERT_EQUAL(a4, a4);

  36.         LOLUNIT_ASSERT_NOT_DIFFERENT(a4, a4);

  37. 

  38.         LOLUNIT_ASSERT_DIFFERENT(a4, b4);

  39.         LOLUNIT_ASSERT_NOT_EQUAL(a4, b4);

  40.         LOLUNIT_ASSERT_DIFFERENT(a4, c4);

  41.         LOLUNIT_ASSERT_NOT_EQUAL(a4, c4);

  42.         LOLUNIT_ASSERT_DIFFERENT(a4, d4);

  43.         LOLUNIT_ASSERT_NOT_EQUAL(a4, d4);

  44.         LOLUNIT_ASSERT_DIFFERENT(a4, e4);

  45.         LOLUNIT_ASSERT_NOT_EQUAL(a4, e4);

  46.     }

  47. 

  48.     LOLUNIT_TEST(UnaryMinus)

  49.     {

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

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

  52. 

  53.         LOLUNIT_ASSERT_EQUAL(a, -b);

  54.         LOLUNIT_ASSERT_EQUAL(-a, b);

  55.     }

  56. 

  57.     LOLUNIT_TEST(Conjugate)

  58.     {

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

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

  61. 

  62.         LOLUNIT_ASSERT_EQUAL(a, ~b);

  63.         LOLUNIT_ASSERT_EQUAL(~a, b);

  64.     }

  65. 

  66.     LOLUNIT_TEST(Norm)

  67.     {

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

  69. 

  70.         LOLUNIT_ASSERT_EQUAL(norm(a), 9.f);

  71. 

  72.         quat b = a * ~a;

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

  74. 

  75.         LOLUNIT_ASSERT_EQUAL(b, c);

  76. 

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

  78. 

  79.         LOLUNIT_ASSERT_EQUAL(norm(a * d), norm(a) * norm(d));

  80.     }

  81. 

  82.     LOLUNIT_TEST(Dot)

  83.     {

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

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

  86. 

  87.         LOLUNIT_ASSERT_EQUAL(dot(a, b), 8.f);

  88.     }

  89. 

  90.     LOLUNIT_TEST(Base)

  91.     {

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

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

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

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

  96. 

  97.         LOLUNIT_ASSERT_EQUAL(norm(one), 1.f);

  98.         LOLUNIT_ASSERT_EQUAL(norm(i), 1.f);

  99.         LOLUNIT_ASSERT_EQUAL(norm(j), 1.f);

  100.         LOLUNIT_ASSERT_EQUAL(norm(k), 1.f);

  101. 

  102.         LOLUNIT_ASSERT_EQUAL(i * i, -one);

  103.         LOLUNIT_ASSERT_EQUAL(j * j, -one);

  104.         LOLUNIT_ASSERT_EQUAL(k * k, -one);

  105.         LOLUNIT_ASSERT_EQUAL(i * j * k, -one);

  106. 

  107.         LOLUNIT_ASSERT_EQUAL(i * j, k);

  108.         LOLUNIT_ASSERT_EQUAL(j * i, -k);

  109.         LOLUNIT_ASSERT_EQUAL(j * k, i);

  110.         LOLUNIT_ASSERT_EQUAL(k * j, -i);

  111.         LOLUNIT_ASSERT_EQUAL(k * i, j);

  112.         LOLUNIT_ASSERT_EQUAL(i * k, -j);

  113.     }

  114. 

  115.     LOLUNIT_TEST(Normalize)

  116.     {

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

  118.         quat b = normalize(a);

  119. 

  120.         LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(b), 1.0, 1e-5);

  121.     }

  122. 

  123.     LOLUNIT_TEST(Reciprocal)

  124.     {

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

  126.         quat b = re(a);

  127.         quat c = 1.f / a;

  128. 

  129.         LOLUNIT_ASSERT_DOUBLES_EQUAL(b.w, c.w, 1e-5);

  130.         LOLUNIT_ASSERT_DOUBLES_EQUAL(b.x, c.x, 1e-5);

  131.         LOLUNIT_ASSERT_DOUBLES_EQUAL(b.y, c.y, 1e-5);

  132.         LOLUNIT_ASSERT_DOUBLES_EQUAL(b.z, c.z, 1e-5);

  133. 

  134.         quat m1 = a * b;

  135.         quat m2 = b * a;

  136.         LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.w, m2.w, 1e-5);

  137.         LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.x, m2.x, 1e-5);

  138.         LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.y, m2.y, 1e-5);

  139.         LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.z, m2.z, 1e-5);

  140. 

  141.         LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.w, 1.0, 1e-5);

  142.         LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.x, 0.0, 1e-5);

  143.         LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.y, 0.0, 1e-5);

  144.         LOLUNIT_ASSERT_DOUBLES_EQUAL(m1.z, 0.0, 1e-5);

  145.     }

  146. 

  147.     LOLUNIT_TEST(Rotation)

  148.     {

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

  150.         quat a = quat::rotate(10.f, vec3(1, 0, 0));

  151.         quat b = quat::rotate(20.f, vec3(1, 0, 0));

  152.         quat c = a * a;

  153. 

  154.         LOLUNIT_ASSERT_DOUBLES_EQUAL(c.w, b.w, 1e-5);

  155.         LOLUNIT_ASSERT_DOUBLES_EQUAL(c.x, b.x, 1e-5);

  156.         LOLUNIT_ASSERT_DOUBLES_EQUAL(c.y, b.y, 1e-5);

  157.         LOLUNIT_ASSERT_DOUBLES_EQUAL(c.z, b.z, 1e-5);

  158. 

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

  160.         quat d = a * b;

  161.         quat e = b * a;

  162. 

  163.         LOLUNIT_ASSERT_DOUBLES_EQUAL(e.w, d.w, 1e-5);

  164.         LOLUNIT_ASSERT_DOUBLES_EQUAL(e.x, d.x, 1e-5);

  165.         LOLUNIT_ASSERT_DOUBLES_EQUAL(e.y, d.y, 1e-5);

  166.         LOLUNIT_ASSERT_DOUBLES_EQUAL(e.z, d.z, 1e-5);

  167.     }

  168. 

  169.     LOLUNIT_TEST(FromTwoVectors)

  170.     {

  171.         vec3 a(1.f, 2.f, 3.f);

  172.         vec3 b(4.f, 5.f, 6.f);

  173.         float ratio = length(a) / length(b);

  174. 

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

  176. 

  177.         /* Check that q transforms a into b */

  178.         vec3 c = q.transform(a);

  179. 

  180.         LOLUNIT_ASSERT_DOUBLES_EQUAL(c.x, b.x * ratio, 1e-5);

  181.         LOLUNIT_ASSERT_DOUBLES_EQUAL(c.y, b.y * ratio, 1e-5);

  182.         LOLUNIT_ASSERT_DOUBLES_EQUAL(c.z, b.z * ratio, 1e-5);

  183. 

  184.         /* Check that ~q transforms b into a */

  185.         vec3 d = (~q).transform(b);

  186. 

  187.         LOLUNIT_ASSERT_DOUBLES_EQUAL(d.x, a.x / ratio, 1e-5);

  188.         LOLUNIT_ASSERT_DOUBLES_EQUAL(d.y, a.y / ratio, 1e-5);

  189.         LOLUNIT_ASSERT_DOUBLES_EQUAL(d.z, a.z / ratio, 1e-5);

  190.     }

  191. 

  192.     LOLUNIT_TEST(FromEulerNorm)

  193.     {

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

  195.         {

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

  197. 

  198.             /* Tait-Bryan */

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

  200.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q1), 1.f, 1e-5);

  201. 

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

  203.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q2), 1.f, 1e-5);

  204. 

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

  206.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q3), 1.f, 1e-5);

  207. 

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

  209.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q4), 1.f, 1e-5);

  210. 

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

  212.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q5), 1.f, 1e-5);

  213. 

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

  215.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q6), 1.f, 1e-5);

  216. 

  217.             /* Euler */

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

  219.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q7), 1.f, 1e-5);

  220. 

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

  222.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q8), 1.f, 1e-5);

  223. 

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

  225.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q9), 1.f, 1e-5);

  226. 

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

  228.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q10), 1.f, 1e-5);

  229. 

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

  231.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q11), 1.f, 1e-5);

  232. 

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

  234.             LOLUNIT_ASSERT_DOUBLES_EQUAL(norm(q12), 1.f, 1e-5);

  235.         }

  236.     }

  237. 

  238.     LOLUNIT_TEST(FirstTwoEulerAngles)

  239.     {

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

  241.         {

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

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

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

  245.             quat q1, q2;

  246. 

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

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

  249. 

  250.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  251.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  252.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  253.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  254. 

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

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

  257. 

  258.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  259.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  260.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  261.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  262. 

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

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

  265. 

  266.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  267.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  268.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  269.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  270. 

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

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

  273. 

  274.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  275.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  276.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  277.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  278. 

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

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

  281. 

  282.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  283.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  284.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  285.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  286. 

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

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

  289. 

  290.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  291.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  292.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  293.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  294.         }

  295.     }

  296. 

  297.     LOLUNIT_TEST(LastTwoEulerAngles)

  298.     {

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

  300.         {

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

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

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

  304.             quat q1, q2;

  305. 

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

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

  308. 

  309.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  310.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  311.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  312.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  313. 

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

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

  316. 

  317.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  318.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  319.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  320.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  321. 

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

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

  324. 

  325.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  326.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  327.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  328.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  329. 

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

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

  332. 

  333.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  334.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  335.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  336.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  337. 

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

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

  340. 

  341.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  342.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  343.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  344.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  345. 

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

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

  348. 

  349.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.w, q2.w, 1e-5);

  350.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.x, q2.x, 1e-5);

  351.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.y, q2.y, 1e-5);

  352.             LOLUNIT_ASSERT_DOUBLES_EQUAL(q1.z, q2.z, 1e-5);

  353.         }

  354.     }

  355. 

  356.     LOLUNIT_TEST(TaitBryanAngles)

  357.     {

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

  359.         {

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

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

  362.              * quaternion creates the same transform. */

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

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

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

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

  367. 

  368.             /* x-y-z */

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

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

  371. 

  372.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  373.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  374.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  375. 

  376.             /* y-z-x */

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

  378.             p1 = q1.transform(p);

  379. 

  380.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  381.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  382.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  383. 

  384.             /* z-x-y */

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

  386.             p1 = q1.transform(p);

  387. 

  388.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  389.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  390.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  391. 

  392.             /* x-z-y */

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

  394.             p1 = q1.transform(p);

  395. 

  396.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  397.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  398.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  399. 

  400.             /* z-y-x */

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

  402.             p1 = q1.transform(p);

  403. 

  404.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  405.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  406.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  407. 

  408.             /* y-x-z */

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

  410.             p1 = q1.transform(p);

  411. 

  412.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  413.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  414.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  415.         }

  416.     }

  417. 

  418.     LOLUNIT_TEST(EulerAngles)

  419.     {

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

  421.         {

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

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

  424.              * quaternion creates the same transform. */

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

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

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

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

  429. 

  430.             /* x-y-x */

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

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

  433. 

  434.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  435.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  436.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  437. 

  438.             /* y-z-y */

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

  440.             p1 = q1.transform(p);

  441. 

  442.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  443.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  444.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  445. 

  446.             /* z-x-z */

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

  448.             p1 = q1.transform(p);

  449. 

  450.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  451.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  452.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  453. 

  454.             /* x-z-x */

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

  456.             p1 = q1.transform(p);

  457. 

  458.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  459.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  460.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  461. 

  462.             /* z-y-z */

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

  464.             p1 = q1.transform(p);

  465. 

  466.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  467.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  468.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  469. 

  470.             /* y-x-y */

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

  472.             p1 = q1.transform(p);

  473. 

  474.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.x, p0.x, 1e-4);

  475.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.y, p0.y, 1e-4);

  476.             LOLUNIT_ASSERT_DOUBLES_EQUAL(p1.z, p0.z, 1e-4);

  477.         }

  478.     }

  479. };

  480. 

  481. } /* namespace lol */