lolengine
/
lol
miroir de https://github.com/lolengine/lol
1
0
Bifurcation 0
Code Tickets 0 Versions 0 Wiki Activité
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
2114 Révisions
5 Branches
789 MiB
 
 
 
Aborescence: 115bd31b0e
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '115bd31b0e'
${ noResults }
lol/test/unit/quat.cpp

544 lignes
18 KiB
Brut Annotations Historique 

  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. #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.         /* Generate identity quaternions */

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

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

  28. 

  29.         /* Generate 90-degree rotations */

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

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

  32. 

  33.         /* Generate 180-degree rotations */

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

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

  36. 

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

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

  39.         {

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

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

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

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

  44.             m_vectorpairs.Push(v1, v2);

  45.         }

  46.     }

  47. 

  48.     void TearDown() {}

  49. 

  50.     LOLUNIT_TEST(Equality)

  51.     {

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

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

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

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

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

  57. 

  58.         LOLUNIT_ASSERT_EQUAL(a4, a4);

  59.         LOLUNIT_ASSERT_NOT_DIFFERENT(a4, a4);

  60. 

  61.         LOLUNIT_ASSERT_DIFFERENT(a4, b4);

  62.         LOLUNIT_ASSERT_NOT_EQUAL(a4, b4);

  63.         LOLUNIT_ASSERT_DIFFERENT(a4, c4);

  64.         LOLUNIT_ASSERT_NOT_EQUAL(a4, c4);

  65.         LOLUNIT_ASSERT_DIFFERENT(a4, d4);

  66.         LOLUNIT_ASSERT_NOT_EQUAL(a4, d4);

  67.         LOLUNIT_ASSERT_DIFFERENT(a4, e4);

  68.         LOLUNIT_ASSERT_NOT_EQUAL(a4, e4);

  69.     }

  70. 

  71.     LOLUNIT_TEST(UnaryMinus)

  72.     {

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

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

  75. 

  76.         LOLUNIT_ASSERT_EQUAL(a, -b);

  77.         LOLUNIT_ASSERT_EQUAL(-a, b);

  78.     }

  79. 

  80.     LOLUNIT_TEST(Conjugate)

  81.     {

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

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

  84. 

  85.         LOLUNIT_ASSERT_EQUAL(a, ~b);

  86.         LOLUNIT_ASSERT_EQUAL(~a, b);

  87.     }

  88. 

  89.     LOLUNIT_TEST(Norm)

  90.     {

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

  92. 

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

  94. 

  95.         quat b = a * ~a;

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

  97. 

  98.         LOLUNIT_ASSERT_EQUAL(b, c);

  99. 

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

  101. 

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

  103.     }

  104. 

  105.     LOLUNIT_TEST(Dot)

  106.     {

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

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

  109. 

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

  111.     }

  112. 

  113.     LOLUNIT_TEST(Base)

  114.     {

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

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

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

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

  119. 

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

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

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

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

  124. 

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

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

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

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

  129. 

  130.         LOLUNIT_ASSERT_EQUAL(i * j, k);

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

  132.         LOLUNIT_ASSERT_EQUAL(j * k, i);

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

  134.         LOLUNIT_ASSERT_EQUAL(k * i, j);

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

  136.     }

  137. 

  138.     LOLUNIT_TEST(Normalize)

  139.     {

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

  141.         quat b = normalize(a);

  142. 

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

  144.     }

  145. 

  146.     LOLUNIT_TEST(Reciprocal)

  147.     {

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

  149.         quat b = re(a);

  150.         quat c = 1.f / a;

  151. 

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

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

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

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

  156. 

  157.         quat m1 = a * b;

  158.         quat m2 = b * a;

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

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

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

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

  163. 

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

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

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

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

  168.     }

  169. 

  170.     LOLUNIT_TEST(Rotation)

  171.     {

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

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

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

  175.         quat c = a * a;

  176. 

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

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

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

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

  181. 

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

  183.         quat d = a * b;

  184.         quat e = b * a;

  185. 

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

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

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

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

  190.     }

  191. 

  192.     LOLUNIT_TEST(ToAxisAngle)

  193.     {

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

  195.         vec3 axis = q.axis();

  196.         float angle = q.angle();

  197. 

  198.         LOLUNIT_ASSERT_DOUBLES_EQUAL(1.0, axis.x, 1e-6);

  199.         LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, axis.y, 1e-6);

  200.         LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, axis.z, 1e-6);

  201. 

  202.         LOLUNIT_ASSERT_DOUBLES_EQUAL(10.0, (double)degrees(angle), 1e-6);

  203.     }

  204. 

  205.     LOLUNIT_TEST(FromTwoVectors)

  206.     {

  207.         for (auto pair : m_vectorpairs)

  208.         {

  209.             vec3 a = pair.m1;

  210.             vec3 b = pair.m2;

  211.             vec3 da = normalize(a);

  212.             vec3 db = normalize(b);

  213. 

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

  215. 

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

  217.             LOLUNIT_ASSERT_DOUBLES_EQUAL(1.0, (double)norm(q), 1e-5);

  218. 

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

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

  221. 

  222.             LOLUNIT_ASSERT_DOUBLES_EQUAL(c.x, db.x, 1e-5);

  223.             LOLUNIT_ASSERT_DOUBLES_EQUAL(c.y, db.y, 1e-5);

  224.             LOLUNIT_ASSERT_DOUBLES_EQUAL(c.z, db.z, 1e-5);

  225. 

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

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

  228. 

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

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

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

  232. 

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

  234.             {

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

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

  237.                 vec3 axis = q.axis();

  238.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, (double)dot(axis, da), 1e-5);

  239.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, (double)dot(axis, db), 1e-5);

  240.             }

  241.             else

  242.             {

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

  244.                  * is zero. */

  245.                 LOLUNIT_ASSERT_DOUBLES_EQUAL(0.0, (double)q.angle(), 1e-5);

  246.             }

  247.         }

  248.     }

  249. 

  250.     LOLUNIT_TEST(FromEulerNorm)

  251.     {

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

  253.         {

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

  255. 

  256.             /* Tait-Bryan */

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

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

  259. 

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

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

  262. 

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

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

  265. 

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

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

  268. 

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

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

  271. 

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

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

  274. 

  275.             /* Euler */

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

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

  278. 

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

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

  281. 

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

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

  284. 

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

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

  287. 

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

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

  290. 

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

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

  293.         }

  294.     }

  295. 

  296.     LOLUNIT_TEST(FirstTwoEulerAngles)

  297.     {

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

  299.         {

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

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

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

  303.             quat q1, q2;

  304. 

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

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

  307. 

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

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

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

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

  312. 

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

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

  315. 

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

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

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

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

  320. 

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

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

  323. 

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

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

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

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

  328. 

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

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

  331. 

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

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

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

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

  336. 

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

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

  339. 

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

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

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

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

  344. 

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

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

  347. 

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

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

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

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

  352.         }

  353.     }

  354. 

  355.     LOLUNIT_TEST(LastTwoEulerAngles)

  356.     {

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

  358.         {

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

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

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

  362.             quat q1, q2;

  363. 

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

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

  366. 

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

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

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

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

  371. 

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

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

  374. 

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

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

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

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

  379. 

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

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

  382. 

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

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

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

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

  387. 

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

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

  390. 

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

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

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

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

  395. 

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

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

  398. 

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

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

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

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

  403. 

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

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

  406. 

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

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

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

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

  411.         }

  412.     }

  413. 

  414.     LOLUNIT_TEST(TaitBryanAngles)

  415.     {

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

  417.         {

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

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

  420.              * quaternion creates the same transform. */

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

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

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

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

  425. 

  426.             /* x-y-z */

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

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

  429. 

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

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

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

  433. 

  434.             /* y-z-x */

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

  436.             p1 = q1.transform(p);

  437. 

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

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

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

  441. 

  442.             /* z-x-y */

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

  444.             p1 = q1.transform(p);

  445. 

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

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

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

  449. 

  450.             /* x-z-y */

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

  452.             p1 = q1.transform(p);

  453. 

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

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

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

  457. 

  458.             /* z-y-x */

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

  460.             p1 = q1.transform(p);

  461. 

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

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

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

  465. 

  466.             /* y-x-z */

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

  468.             p1 = q1.transform(p);

  469. 

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

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

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

  473.         }

  474.     }

  475. 

  476.     LOLUNIT_TEST(EulerAngles)

  477.     {

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

  479.         {

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

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

  482.              * quaternion creates the same transform. */

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

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

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

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

  487. 

  488.             /* x-y-x */

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

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

  491. 

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

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

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

  495. 

  496.             /* y-z-y */

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

  498.             p1 = q1.transform(p);

  499. 

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

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

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

  503. 

  504.             /* z-x-z */

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

  506.             p1 = q1.transform(p);

  507. 

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

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

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

  511. 

  512.             /* x-z-x */

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

  514.             p1 = q1.transform(p);

  515. 

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

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

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

  519. 

  520.             /* z-y-z */

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

  522.             p1 = q1.transform(p);

  523. 

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

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

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

  527. 

  528.             /* y-x-y */

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

  530.             p1 = q1.transform(p);

  531. 

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

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

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

  535.         }

  536.     }

  537. 

  538. private:

  539.     Array<vec3, vec3> m_vectorpairs;

  540. };

  541. 

  542. } /* namespace lol */