Whitespace and language change

- changed tabs to spaces and DOS line endings to Unix
  (except in CBot and metafile)
- changed language to English
- fixed #include <d3d.h> in d3dengine.h

3 files changed, 608 insertions, 608 deletions

diff --git a/src/math/test/geometry_test.cpp b/src/math/test/geometry_test.cpp
index d6dbd9b..07fa2cf 100644
--- a/src/math/test/geometry_test.cpp
+++ b/src/math/test/geometry_test.cpp
@@ -35,367 +35,367 @@ const float TEST_TOLERANCE = 1e-5;
 // Test for rewritten function RotateAngle()
 int TestRotateAngle()
 {
-  if (! Math::IsEqual(Math::RotateAngle(0.0f, 0.0f), 0.0f, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(0.0f, 0.0f), 0.0f, TEST_TOLERANCE))
+        return __LINE__;
 
-  if (! Math::IsEqual(Math::RotateAngle(1.0f, 0.0f), 0.0f, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(1.0f, 0.0f), 0.0f, TEST_TOLERANCE))
+        return __LINE__;
 
-  if (! Math::IsEqual(Math::RotateAngle(1.0f, 1.0f), 0.25f * Math::PI, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(1.0f, 1.0f), 0.25f * Math::PI, TEST_TOLERANCE))
+        return __LINE__;
 
-  if (! Math::IsEqual(Math::RotateAngle(0.0f, 2.0f), 0.5f * Math::PI, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(0.0f, 2.0f), 0.5f * Math::PI, TEST_TOLERANCE))
+        return __LINE__;
 
-  if (! Math::IsEqual(Math::RotateAngle(-0.5f, 0.5f), 0.75f * Math::PI, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(-0.5f, 0.5f), 0.75f * Math::PI, TEST_TOLERANCE))
+        return __LINE__;
 
-  if (! Math::IsEqual(Math::RotateAngle(-1.0f, 0.0f), Math::PI, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(-1.0f, 0.0f), Math::PI, TEST_TOLERANCE))
+        return __LINE__;
 
-  if (! Math::IsEqual(Math::RotateAngle(-1.0f, -1.0f), 1.25f * Math::PI, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(-1.0f, -1.0f), 1.25f * Math::PI, TEST_TOLERANCE))
+        return __LINE__;
 
-  if (! Math::IsEqual(Math::RotateAngle(0.0f, -2.0f), 1.5f * Math::PI, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(0.0f, -2.0f), 1.5f * Math::PI, TEST_TOLERANCE))
+        return __LINE__;
 
-  if (! Math::IsEqual(Math::RotateAngle(1.0f, -1.0f), 1.75f * Math::PI, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::IsEqual(Math::RotateAngle(1.0f, -1.0f), 1.75f * Math::PI, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 // Tests for other altered, complex or uncertain functions
 
 int TestAngle()
 {
-  const Math::Vector u(-0.0786076246943884, 0.2231249091714256, -1.1601361718477805);
-  const Math::Vector v(-1.231228742001907, -1.720549809950561, -0.690468438834111);
+    const Math::Vector u(-0.0786076246943884, 0.2231249091714256, -1.1601361718477805);
+    const Math::Vector v(-1.231228742001907, -1.720549809950561, -0.690468438834111);
 
-  float mathResult = Math::Angle(u, v);
-  float oldMathResult = Angle(VEC_TO_D3DVEC(u), VEC_TO_D3DVEC(v));
+    float mathResult = Math::Angle(u, v);
+    float oldMathResult = Angle(VEC_TO_D3DVEC(u), VEC_TO_D3DVEC(v));
 
-  if (! Math::IsEqual(mathResult, oldMathResult, TEST_TOLERANCE) )
-    return __LINE__;
+    if (! Math::IsEqual(mathResult, oldMathResult, TEST_TOLERANCE) )
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestRotateView()
 {
-  const Math::Vector center(0.617909142705555, 0.896939729454538, -0.615041943652284);
-  const float angleH = 44.5;
-  const float angleV = 12.3;
-  const float dist = 34.76;
+    const Math::Vector center(0.617909142705555, 0.896939729454538, -0.615041943652284);
+    const float angleH = 44.5;
+    const float angleV = 12.3;
+    const float dist = 34.76;
 
-  Math::Vector mathResult = Math::RotateView(center, angleH, angleV, dist);
-  Math::Vector oldMathResult = D3DVEC_TO_VEC(RotateView(VEC_TO_D3DVEC(center), angleH, angleV, dist));
+    Math::Vector mathResult = Math::RotateView(center, angleH, angleV, dist);
+    Math::Vector oldMathResult = D3DVEC_TO_VEC(RotateView(VEC_TO_D3DVEC(center), angleH, angleV, dist));
 
-  if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLookatPoint()
 {
-  const Math::Vector eye(-2.451183170579471,  0.241270270546559, -0.490677411454893);
-  const float angleH = 48.4;
-  const float angleV = 32.4;
-  const float length = 74.44;
+    const Math::Vector eye(-2.451183170579471,  0.241270270546559, -0.490677411454893);
+    const float angleH = 48.4;
+    const float angleV = 32.4;
+    const float length = 74.44;
 
-  Math::Vector mathResult = Math::LookatPoint(eye, angleH, angleV, length);
-  Math::Vector oldMathResult = D3DVEC_TO_VEC(LookatPoint(VEC_TO_D3DVEC(eye), angleH, angleV, length));
+    Math::Vector mathResult = Math::LookatPoint(eye, angleH, angleV, length);
+    Math::Vector oldMathResult = D3DVEC_TO_VEC(LookatPoint(VEC_TO_D3DVEC(eye), angleH, angleV, length));
 
-  if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestProjection()
 {
-  const Math::Vector a(0.852064846846319, -0.794279497087496, -0.655779805476688);
-  const Math::Vector b(-0.245838834102304, -0.841115596038861, 0.470457161487799);
-  const Math::Vector p(2.289326061164255, -0.505511362271196,  0.660204551169491);
+    const Math::Vector a(0.852064846846319, -0.794279497087496, -0.655779805476688);
+    const Math::Vector b(-0.245838834102304, -0.841115596038861, 0.470457161487799);
+    const Math::Vector p(2.289326061164255, -0.505511362271196,  0.660204551169491);
 
-  Math::Vector mathResult = Math::Projection(a, b, p);
-  Math::Vector oldMathResult = D3DVEC_TO_VEC(Projection(VEC_TO_D3DVEC(a), VEC_TO_D3DVEC(b), VEC_TO_D3DVEC(p)));
+    Math::Vector mathResult = Math::Projection(a, b, p);
+    Math::Vector oldMathResult = D3DVEC_TO_VEC(Projection(VEC_TO_D3DVEC(a), VEC_TO_D3DVEC(b), VEC_TO_D3DVEC(p)));
 
-  if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadViewMatrix()
 {
-  const Math::Vector from(2.5646013154868874, -0.6058794133917031, -0.0441195127419744);
-  const Math::Vector at(0.728044925765569, -0.206343977871841, 2.543158236935463);
-  const Math::Vector worldUp(-1.893738133660711, -1.009584441407070, 0.521745988225582);
-
-  Math::Matrix mathResult;
-  Math::LoadViewMatrix(mathResult, from, at, worldUp);
-
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    D3DVECTOR fromD3D = VEC_TO_D3DVEC(from);
-    D3DVECTOR atD3D = VEC_TO_D3DVEC(at);
-    D3DVECTOR worldUpD3D = VEC_TO_D3DVEC(worldUp);
-    D3DUtil_SetViewMatrix(mat, fromD3D, atD3D, worldUpD3D);
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
-
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
-
-  return 0;
+    const Math::Vector from(2.5646013154868874, -0.6058794133917031, -0.0441195127419744);
+    const Math::Vector at(0.728044925765569, -0.206343977871841, 2.543158236935463);
+    const Math::Vector worldUp(-1.893738133660711, -1.009584441407070, 0.521745988225582);
+
+    Math::Matrix mathResult;
+    Math::LoadViewMatrix(mathResult, from, at, worldUp);
+
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        D3DVECTOR fromD3D = VEC_TO_D3DVEC(from);
+        D3DVECTOR atD3D = VEC_TO_D3DVEC(at);
+        D3DVECTOR worldUpD3D = VEC_TO_D3DVEC(worldUp);
+        D3DUtil_SetViewMatrix(mat, fromD3D, atD3D, worldUpD3D);
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
+
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
+
+    return 0;
 }
 
 int TestLoadProjectionMatrix()
 {
-  const float fov = 76.3f;
-  const float aspect = 0.891f;
-  const float nearPlane = 12.3f;
-  const float farPlane = 1238.9f;
+    const float fov = 76.3f;
+    const float aspect = 0.891f;
+    const float nearPlane = 12.3f;
+    const float farPlane = 1238.9f;
 
-  Math::Matrix mathResult;
-  Math::LoadProjectionMatrix(mathResult, fov, aspect, nearPlane, farPlane);
+    Math::Matrix mathResult;
+    Math::LoadProjectionMatrix(mathResult, fov, aspect, nearPlane, farPlane);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    D3DUtil_SetProjectionMatrix(mat, fov, aspect, nearPlane, farPlane);
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        D3DUtil_SetProjectionMatrix(mat, fov, aspect, nearPlane, farPlane);
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadTranslationMatrix()
 {
-  const Math::Vector translation(-0.3631590720995237, 1.6976327614875211, 0.0148815191502145);
+    const Math::Vector translation(-0.3631590720995237, 1.6976327614875211, 0.0148815191502145);
 
-  Math::Matrix mathResult;
-  Math::LoadTranslationMatrix(mathResult, translation);
+    Math::Matrix mathResult;
+    Math::LoadTranslationMatrix(mathResult, translation);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    D3DUtil_SetTranslateMatrix(mat, translation.x, translation.y, translation.z);
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        D3DUtil_SetTranslateMatrix(mat, translation.x, translation.y, translation.z);
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadScaleMatrix()
 {
-  const Math::Vector scale(0.612236460285503, -0.635566935025364, -0.254321375332065);
+    const Math::Vector scale(0.612236460285503, -0.635566935025364, -0.254321375332065);
 
-  Math::Matrix mathResult;
-  Math::LoadScaleMatrix(mathResult, scale);
+    Math::Matrix mathResult;
+    Math::LoadScaleMatrix(mathResult, scale);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    D3DUtil_SetScaleMatrix(mat, scale.x, scale.y, scale.z);
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        D3DUtil_SetScaleMatrix(mat, scale.x, scale.y, scale.z);
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadRotationXMatrix()
 {
-  const float angle = 0.513790685774275;
+    const float angle = 0.513790685774275;
 
-  Math::Matrix mathResult;
-  Math::LoadRotationXMatrix(mathResult, angle);
+    Math::Matrix mathResult;
+    Math::LoadRotationXMatrix(mathResult, angle);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    D3DUtil_SetRotateXMatrix(mat, angle);
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        D3DUtil_SetRotateXMatrix(mat, angle);
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadRotationYMatrix()
 {
-  const float angle = -0.569166650127303;
+    const float angle = -0.569166650127303;
 
-  Math::Matrix mathResult;
-  Math::LoadRotationYMatrix(mathResult, angle);
+    Math::Matrix mathResult;
+    Math::LoadRotationYMatrix(mathResult, angle);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    D3DUtil_SetRotateYMatrix(mat, angle);
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        D3DUtil_SetRotateYMatrix(mat, angle);
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadRotationZMatrix()
 {
-  const float angle = 0.380448034347452;
+    const float angle = 0.380448034347452;
 
-  Math::Matrix mathResult;
-  Math::LoadRotationZMatrix(mathResult, angle);
+    Math::Matrix mathResult;
+    Math::LoadRotationZMatrix(mathResult, angle);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    D3DUtil_SetRotateZMatrix(mat, angle);
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        D3DUtil_SetRotateZMatrix(mat, angle);
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadRotationMatrix()
 {
-  const float angle = -0.987747190637790;
-  const Math::Vector dir(-0.113024727688331, -0.781265998072571, 1.838972397076884);
+    const float angle = -0.987747190637790;
+    const Math::Vector dir(-0.113024727688331, -0.781265998072571, 1.838972397076884);
 
-  Math::Matrix mathResult;
-  Math::LoadRotationMatrix(mathResult, dir, angle);
+    Math::Matrix mathResult;
+    Math::LoadRotationMatrix(mathResult, dir, angle);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    D3DVECTOR dirD3D = VEC_TO_D3DVEC(dir);
-    D3DUtil_SetRotationMatrix(mat, dirD3D, angle);
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        D3DVECTOR dirD3D = VEC_TO_D3DVEC(dir);
+        D3DUtil_SetRotationMatrix(mat, dirD3D, angle);
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadRotationXZYMatrix()
 {
-  const Math::Vector angles(-0.841366567984597, -0.100543315396357, 1.610647811559988);
+    const Math::Vector angles(-0.841366567984597, -0.100543315396357, 1.610647811559988);
 
-  Math::Matrix mathResult;
-  Math::LoadRotationXZYMatrix(mathResult, angles);
+    Math::Matrix mathResult;
+    Math::LoadRotationXZYMatrix(mathResult, angles);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    MatRotateXZY(mat, VEC_TO_D3DVEC(angles));
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        MatRotateXZY(mat, VEC_TO_D3DVEC(angles));
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestLoadRotationZXYMatrix()
 {
-  const Math::Vector angles(0.275558495480206, -0.224328265970090, 0.943077216574253);
+    const Math::Vector angles(0.275558495480206, -0.224328265970090, 0.943077216574253);
 
-  Math::Matrix mathResult;
-  Math::LoadRotationZXYMatrix(mathResult, angles);
+    Math::Matrix mathResult;
+    Math::LoadRotationZXYMatrix(mathResult, angles);
 
-  Math::Matrix oldMathResult;
-  {
-    D3DMATRIX mat;
-    MatRotateZXY(mat, VEC_TO_D3DVEC(angles));
-    oldMathResult = D3DMAT_TO_MAT(mat);
-  }
+    Math::Matrix oldMathResult;
+    {
+        D3DMATRIX mat;
+        MatRotateZXY(mat, VEC_TO_D3DVEC(angles));
+        oldMathResult = D3DMAT_TO_MAT(mat);
+    }
 
-  if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
+    if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
 
-  return 0;
+    return 0;
 }
 
 int TestTransform()
 {
-  Math::Matrix transformMatrix(
-    (float[4][4])
-    {
-      { -0.9282074720977896,  0.6794734970319730, -1.3234304946882685,  0.0925294727863890 },
-      { -0.0395527963683484,  0.2897634352353881,  1.9144398570315440, -1.4062267508968478 },
-      {  0.9133323625282361, -0.6741836434774530, -0.2188812951424338, -1.0089184339952666 },
-      {  0.0f, 0.0f, 0.0f, 1.0f }
-    }
-  );
-  Math::Vector vector(-0.314596433318370, -0.622681232583150, -0.371307535743574);
-
-  Math::Vector mathResult = Math::Transform(transformMatrix, vector);
-  Math::Vector oldMathResult = Transform(transformMatrix, vector);
-
-  if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
-    return __LINE__;
-
-  return 0;
+    Math::Matrix transformMatrix(
+        (float[4][4])
+        {
+            { -0.9282074720977896,  0.6794734970319730, -1.3234304946882685,  0.0925294727863890 },
+            { -0.0395527963683484,  0.2897634352353881,  1.9144398570315440, -1.4062267508968478 },
+            {  0.9133323625282361, -0.6741836434774530, -0.2188812951424338, -1.0089184339952666 },
+            {  0.0f, 0.0f, 0.0f, 1.0f }
+        }
+    );
+    Math::Vector vector(-0.314596433318370, -0.622681232583150, -0.371307535743574);
+
+    Math::Vector mathResult = Math::Transform(transformMatrix, vector);
+    Math::Vector oldMathResult = Transform(transformMatrix, vector);
+
+    if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+        return __LINE__;
+
+    return 0;
 }
 
 int main()
 {
-  // Functions to test
-  int (*TESTS[])() =
-  {
-    TestRotateAngle,
-    TestAngle,
-    TestRotateView,
-    TestLookatPoint,
-    TestProjection,
-    TestLoadViewMatrix,
-    TestLoadProjectionMatrix,
-    TestLoadTranslationMatrix,
-    TestLoadScaleMatrix,
-    TestLoadRotationXMatrix,
-    TestLoadRotationYMatrix,
-    TestLoadRotationZMatrix,
-    TestLoadRotationMatrix,
-    TestLoadRotationXZYMatrix,
-    TestLoadRotationZXYMatrix,
-    TestTransform
-  };
-  const int TESTS_SIZE = sizeof(TESTS) / sizeof(*TESTS);
-
-  int result = 0;
-  for (int i = 0; i < TESTS_SIZE; ++i)
-  {
-    result = TESTS[i]();
-    if (result != 0)
+    // Functions to test
+    int (*TESTS[])() =
+    {
+        TestRotateAngle,
+        TestAngle,
+        TestRotateView,
+        TestLookatPoint,
+        TestProjection,
+        TestLoadViewMatrix,
+        TestLoadProjectionMatrix,
+        TestLoadTranslationMatrix,
+        TestLoadScaleMatrix,
+        TestLoadRotationXMatrix,
+        TestLoadRotationYMatrix,
+        TestLoadRotationZMatrix,
+        TestLoadRotationMatrix,
+        TestLoadRotationXZYMatrix,
+        TestLoadRotationZXYMatrix,
+        TestTransform
+    };
+    const int TESTS_SIZE = sizeof(TESTS) / sizeof(*TESTS);
+
+    int result = 0;
+    for (int i = 0; i < TESTS_SIZE; ++i)
     {
-      fprintf(stderr, "Test function %d failed at line %d\n", i+1, result);
-      return result;
+        result = TESTS[i]();
+        if (result != 0)
+        {
+            fprintf(stderr, "Test function %d failed at line %d\n", i+1, result);
+            return result;
+        }
     }
-  }
 
-  fprintf(stderr, "All tests successful\n");
+    fprintf(stderr, "All tests successful\n");
 
-  return 0;
+    return 0;
 }
diff --git a/src/math/test/matrix_test.cpp b/src/math/test/matrix_test.cpp
index 95f1ed7..663234c 100644
--- a/src/math/test/matrix_test.cpp
+++ b/src/math/test/matrix_test.cpp
@@ -16,11 +16,11 @@
 
 // math/test/matrix_test.cpp
 
-/* Unit tests for Matrix struct
-
-   Test data was randomly generated and the expected results
-   calculated using GNU Octave.
+/*
+  Unit tests for Matrix struct
 
+  Test data was randomly generated and the expected results
+  calculated using GNU Octave.
  */
 
 #include "../func.h"
@@ -34,369 +34,369 @@ const float TEST_TOLERANCE = 1e-6;
 
 int TestTranspose()
 {
-  const Math::Matrix mat(
-    (float[4][4])
-    {
-      { -0.07011674491203920,  1.26145596067429810,  2.09476603598066902,  0.35560176915570696 },
-      { -1.34075615966224704,  1.17988499016709314,  0.00601713429241016, -0.75213676977972566 },
-      {  0.59186722295223981,  0.88089224074765293,  0.70994467464257294,  0.36730385425340212 },
-      { -0.95649396555068111,  0.75912182022565566,  1.34883305778387186, -1.34957997578168754 }
-    }
-  );
-
-  const Math::Matrix expectedTranspose(
-    (float[4][4])
+    const Math::Matrix mat(
+        (float[4][4])
+        {
+            { -0.07011674491203920,  1.26145596067429810,  2.09476603598066902,  0.35560176915570696 },
+            { -1.34075615966224704,  1.17988499016709314,  0.00601713429241016, -0.75213676977972566 },
+            {  0.59186722295223981,  0.88089224074765293,  0.70994467464257294,  0.36730385425340212 },
+            { -0.95649396555068111,  0.75912182022565566,  1.34883305778387186, -1.34957997578168754 }
+        }
+    );
+
+    const Math::Matrix expectedTranspose(
+        (float[4][4])
+        {
+            { -0.07011674491203920, -1.34075615966224704,  0.59186722295223981, -0.95649396555068111 },
+            {  1.26145596067429810,  1.17988499016709314,  0.88089224074765293,  0.75912182022565566 },
+            {  2.09476603598066902,  0.00601713429241016,  0.70994467464257294,  1.34883305778387186 },
+            {  0.35560176915570696, -0.75213676977972566,  0.36730385425340212, -1.34957997578168754 }
+        }
+    );
+
+    Math::Matrix transpose = Math::Transpose(mat);
+
+    if (! Math::MatricesEqual(transpose, expectedTranspose, TEST_TOLERANCE))
     {
-      { -0.07011674491203920, -1.34075615966224704,  0.59186722295223981, -0.95649396555068111 },
-      {  1.26145596067429810,  1.17988499016709314,  0.88089224074765293,  0.75912182022565566 },
-      {  2.09476603598066902,  0.00601713429241016,  0.70994467464257294,  1.34883305778387186 },
-      {  0.35560176915570696, -0.75213676977972566,  0.36730385425340212, -1.34957997578168754 }
+        fprintf(stderr, "Transpose mismatch!\n");
+        return __LINE__;
     }
-  );
-
-  Math::Matrix transpose = Math::Transpose(mat);
 
-  if (! Math::MatricesEqual(transpose, expectedTranspose, TEST_TOLERANCE))
-  {
-    fprintf(stderr, "Transpose mismatch!\n");
-    return __LINE__;
-  }
-
-  return 0;
+    return 0;
 }
 
 int TestCofactor()
 {
-  const Math::Matrix mat1(
-    (float[4][4])
-    {
-      {  0.610630320796245,  1.059932357918312, -1.581674311378210,  1.782214448453331 },
-      {  0.191028848211526, -0.813898708757524,  1.516114203870644,  0.395202639476002 },
-      {  0.335142750345279, -0.346586619596529,  0.545382042472336, -0.879268918923072 },
-      {  1.417588151657198,  1.450841789070141,  0.219080104196171,  0.378724047481655 }
-    }
-  );
-
-  const Math::Matrix expectedCofactors1(
-    (float[4][4])
-    {
-      { -2.402679369186782,  2.282452509293019,  1.722732204057644, -0.746939701104385 },
-      { -0.687677756877654,  1.168949180331164, -0.985354966837796, -1.334071111592705 },
-      { -5.115621958424845,  4.229724770159009,  2.529000630782808,  1.481632618355891 },
-      {  0.147480897398694, -2.140677680337111, -1.207189492265546,  0.151236920408051 }
-    }
-  );
-
-  for (int r = 0; r < 4; ++r)
-  {
-    for (int c = 0; c < 4; ++c)
-    {
-      float ret = mat1.Cofactor(r, c);
-      float exp = expectedCofactors1.m[4*c+r];
-      if (! Math::IsEqual(ret, exp, TEST_TOLERANCE))
-      {
-        fprintf(stderr, "Cofactors 1 mismatch!\n");
-        fprintf(stderr, "r=%d, c=%d, %f (returned) != %f (expected)\n", r, c, ret, exp);
-        return __LINE__;
-      }
-    }
-  }
-
-  const Math::Matrix mat2(
-    (float[4][4])
-    {
-      {  0.9845099464982393, -0.9091233416532389, -0.6272243714245945,  0.4645001858944354 },
-      { -0.1333308471483736,  0.9128181433725897, -1.0937461393836190,  0.3180936795928376 },
-      { -0.0654324396846289,  0.1014641705415945,  1.5107709042683430, -0.0240560430414690 },
-      {  0.0179638644093347, -1.0695585982782767, -0.1741250853101032,  1.0803106709464336 }
-    }
-  );
-
-  const Math::Matrix expectedCofactors2(
-    (float[4][4])
+    const Math::Matrix mat1(
+        (float[4][4])
+        {
+            {  0.610630320796245,  1.059932357918312, -1.581674311378210,  1.782214448453331 },
+            {  0.191028848211526, -0.813898708757524,  1.516114203870644,  0.395202639476002 },
+            {  0.335142750345279, -0.346586619596529,  0.545382042472336, -0.879268918923072 },
+            {  1.417588151657198,  1.450841789070141,  0.219080104196171,  0.378724047481655 }
+        }
+    );
+
+    const Math::Matrix expectedCofactors1(
+        (float[4][4])
+        {
+            { -2.402679369186782,  2.282452509293019,  1.722732204057644, -0.746939701104385 },
+            { -0.687677756877654,  1.168949180331164, -0.985354966837796, -1.334071111592705 },
+            { -5.115621958424845,  4.229724770159009,  2.529000630782808,  1.481632618355891 },
+            {  0.147480897398694, -2.140677680337111, -1.207189492265546,  0.151236920408051 }
+        }
+    );
+
+    for (int r = 0; r < 4; ++r)
     {
-      {  2.0861102207614466,  0.2989010779528912,  0.0746276150537432,  0.2732659822656097 },
-      {  0.6850002886584565,  1.5513169659641379, -0.0503743176545917,  1.5163672441575642 },
-      {  1.2385556680997216,  1.1827709562505695,  1.2282813085138962,  1.3483789679871401 },
-      { -1.0710790241539783, -0.5589604503588883,  0.0100959837872308,  1.1897872684455839 }
+        for (int c = 0; c < 4; ++c)
+        {
+            float ret = mat1.Cofactor(r, c);
+            float exp = expectedCofactors1.m[4*c+r];
+            if (! Math::IsEqual(ret, exp, TEST_TOLERANCE))
+            {
+                fprintf(stderr, "Cofactors 1 mismatch!\n");
+                fprintf(stderr, "r=%d, c=%d, %f (returned) != %f (expected)\n", r, c, ret, exp);
+                return __LINE__;
+            }
+        }
     }
-  );
 
-
-  for (int r = 0; r < 4; ++r)
-  {
-    for (int c = 0; c < 4; ++c)
+    const Math::Matrix mat2(
+        (float[4][4])
+        {
+            {  0.9845099464982393, -0.9091233416532389, -0.6272243714245945,  0.4645001858944354 },
+            { -0.1333308471483736,  0.9128181433725897, -1.0937461393836190,  0.3180936795928376 },
+            { -0.0654324396846289,  0.1014641705415945,  1.5107709042683430, -0.0240560430414690 },
+            {  0.0179638644093347, -1.0695585982782767, -0.1741250853101032,  1.0803106709464336 }
+        }
+    );
+
+    const Math::Matrix expectedCofactors2(
+        (float[4][4])
+        {
+            {  2.0861102207614466,  0.2989010779528912,  0.0746276150537432,  0.2732659822656097 },
+            {  0.6850002886584565,  1.5513169659641379, -0.0503743176545917,  1.5163672441575642 },
+            {  1.2385556680997216,  1.1827709562505695,  1.2282813085138962,  1.3483789679871401 },
+            { -1.0710790241539783, -0.5589604503588883,  0.0100959837872308,  1.1897872684455839 }
+        }
+    );
+
+
+    for (int r = 0; r < 4; ++r)
     {
-      float ret = mat2.Cofactor(r, c);
-      float exp = expectedCofactors2.m[4*c+r];
-      if (! Math::IsEqual(ret, exp, TEST_TOLERANCE))
-      {
-        fprintf(stderr, "Cofactors 2 mismatch!\n");
-        fprintf(stderr, "r=%d, c=%d, %f (returned) != %f (expected)\n", r, c, ret, exp);
-        return __LINE__;
-      }
+        for (int c = 0; c < 4; ++c)
+        {
+            float ret = mat2.Cofactor(r, c);
+            float exp = expectedCofactors2.m[4*c+r];
+            if (! Math::IsEqual(ret, exp, TEST_TOLERANCE))
+            {
+                fprintf(stderr, "Cofactors 2 mismatch!\n");
+                fprintf(stderr, "r=%d, c=%d, %f (returned) != %f (expected)\n", r, c, ret, exp);
+                return __LINE__;
+            }
+        }
     }
-  }
 
-  return 0;
+    return 0;
 }
 
 int TestDet()
 {
-  const Math::Matrix mat1(
-    (float[4][4])
+    const Math::Matrix mat1(
+        (float[4][4])
+        {
+            { -0.95880162984708284,  0.24004047608997131, -0.78172309932665407, -0.11604124457222834 },
+            { -0.36230592086261376, -0.75778166876017261,  0.33041059404631740, -1.06001391941094836 },
+            {  0.00260215210936187,  1.27485610196385113, -0.26149859846418033, -0.59669701186364876 },
+            {  0.36899429848485432,  3.01720896813933104,  2.10311476609438719, -1.68627076626448269 }
+        }
+    );
+
+    const float expectedDet1 = 4.07415413729671;
+
+    float ret1 = mat1.Det();
+    if (! Math::IsEqual(ret1, expectedDet1, TEST_TOLERANCE))
     {
-      { -0.95880162984708284,  0.24004047608997131, -0.78172309932665407, -0.11604124457222834 },
-      { -0.36230592086261376, -0.75778166876017261,  0.33041059404631740, -1.06001391941094836 },
-      {  0.00260215210936187,  1.27485610196385113, -0.26149859846418033, -0.59669701186364876 },
-      {  0.36899429848485432,  3.01720896813933104,  2.10311476609438719, -1.68627076626448269 }
+        fprintf(stderr, "Det mismatch!\n");
+        fprintf(stderr, "%f (returned) != %f (expected)\n", ret1, expectedDet1);
+        return __LINE__;
     }
-  );
 
-  const float expectedDet1 = 4.07415413729671;
+    const Math::Matrix mat2(
+        (float[4][4])
+        {
+            { -1.0860073221346871,  0.9150354098189495, -0.2723201933559999,  0.2922832160271507 },
+            { -1.0248331304801788, -2.5081237461125205, -1.0277123574586633, -0.2254690663329798 },
+            { -1.4227635282899367, -0.0403846809122684,  0.9216148477171653,  1.2517067488015878 },
+            { -0.1160254467152022,  0.8270675274393656,  1.0327218739781614, -0.3674886870220400 }
+        }
+    );
 
-  float ret1 = mat1.Det();
-  if (! Math::IsEqual(ret1, expectedDet1, TEST_TOLERANCE))
-  {
-    fprintf(stderr, "Det mismatch!\n");
-    fprintf(stderr, "%f (returned) != %f (expected)\n", ret1, expectedDet1);
-    return __LINE__;
-  }
+    const float expectedDet2 = -6.35122307880942;
 
-  const Math::Matrix mat2(
-    (float[4][4])
+    float ret2 = mat2.Det();
+    if (! Math::IsEqual(ret2, expectedDet2, TEST_TOLERANCE))
     {
-      { -1.0860073221346871,  0.9150354098189495, -0.2723201933559999,  0.2922832160271507 },
-      { -1.0248331304801788, -2.5081237461125205, -1.0277123574586633, -0.2254690663329798 },
-      { -1.4227635282899367, -0.0403846809122684,  0.9216148477171653,  1.2517067488015878 },
-      { -0.1160254467152022,  0.8270675274393656,  1.0327218739781614, -0.3674886870220400 }
+        fprintf(stderr, "Det mismatch!\n");
+        fprintf(stderr, "%f (returned) != %f (expected)\n", ret2, expectedDet2);
+        return __LINE__;
     }
-  );
 
-  const float expectedDet2 = -6.35122307880942;
-
-  float ret2 = mat2.Det();
-  if (! Math::IsEqual(ret2, expectedDet2, TEST_TOLERANCE))
-  {
-    fprintf(stderr, "Det mismatch!\n");
-    fprintf(stderr, "%f (returned) != %f (expected)\n", ret2, expectedDet2);
-    return __LINE__;
-  }
-
-  return 0;
+    return 0;
 }
 
 int TestInverse()
 {
-  const Math::Matrix mat1(
-    (float[4][4])
-    {
-      { -2.2829352811514658, -0.9103222363187888,  0.2792976509411680, -0.7984393573193174 },
-      {  2.4823665798689589, -0.0599056759070980,  0.3832364352926366, -1.6404257204372739 },
-      { -0.3841952272526398, -0.8377700696457873, -0.3416328338427138,  1.1746577275723329 },
-      {  0.1746031241954947, -0.4952532117949962,  0.2155084379835037, -1.6586460437329220 }
-    }
-  );
-
-  const Math::Matrix expectedInverse1(
-    (float[4][4])
-    {
-      { -0.119472603171041,  0.331675963276297,  0.187516809009720, -0.137720814290806 },
-      { -0.387591686166085, -0.487284946727583, -0.798527541290274,  0.102991635972060 },
-      {  2.601905603425902,  2.606899016264679, -0.528006148839176, -4.204703326522837 },
-      {  0.441220327151392,  0.519128136207318,  0.189567009205522, -1.194469716136194 }
-    }
-  );
-
-  Math::Matrix inverse1 = mat1.Inverse();
-
-  if (! Math::MatricesEqual(inverse1, expectedInverse1, TEST_TOLERANCE))
-  {
-    fprintf(stderr, "Inverse 1 mismatch!\n");
-    return __LINE__;
-  }
-
-  const Math::Matrix mat2(
-    (float[4][4])
+    const Math::Matrix mat1(
+        (float[4][4])
+        {
+            { -2.2829352811514658, -0.9103222363187888,  0.2792976509411680, -0.7984393573193174 },
+            {  2.4823665798689589, -0.0599056759070980,  0.3832364352926366, -1.6404257204372739 },
+            { -0.3841952272526398, -0.8377700696457873, -0.3416328338427138,  1.1746577275723329 },
+            {  0.1746031241954947, -0.4952532117949962,  0.2155084379835037, -1.6586460437329220 }
+        }
+    );
+
+    const Math::Matrix expectedInverse1(
+        (float[4][4])
+        {
+            { -0.119472603171041,  0.331675963276297,  0.187516809009720, -0.137720814290806 },
+            { -0.387591686166085, -0.487284946727583, -0.798527541290274,  0.102991635972060 },
+            {  2.601905603425902,  2.606899016264679, -0.528006148839176, -4.204703326522837 },
+            {  0.441220327151392,  0.519128136207318,  0.189567009205522, -1.194469716136194 }
+        }
+    );
+
+    Math::Matrix inverse1 = mat1.Inverse();
+
+    if (! Math::MatricesEqual(inverse1, expectedInverse1, TEST_TOLERANCE))
     {
-      { -0.05464332404298505, -0.64357755258235749, -0.13017671677619302, -0.56742332785888006 },
-      {  0.29048383600458222, -0.91517047043724875,  0.84517524415561684,  0.51628195547960565 },
-      {  0.00946488004480186, -0.89077382212689293,  0.73565573766341397, -0.15932513521840930 },
-      { -1.01244718912499132, -0.27840911963972276, -0.39189681211309862,  1.18315064340192055 }
+        fprintf(stderr, "Inverse 1 mismatch!\n");
+        return __LINE__;
     }
-  );
 
-  const Math::Matrix expectedInverse2(
-    (float[4][4])
+    const Math::Matrix mat2(
+        (float[4][4])
+        {
+            { -0.05464332404298505, -0.64357755258235749, -0.13017671677619302, -0.56742332785888006 },
+            {  0.29048383600458222, -0.91517047043724875,  0.84517524415561684,  0.51628195547960565 },
+            {  0.00946488004480186, -0.89077382212689293,  0.73565573766341397, -0.15932513521840930 },
+            { -1.01244718912499132, -0.27840911963972276, -0.39189681211309862,  1.18315064340192055 }
+        }
+    );
+
+    const Math::Matrix expectedInverse2(
+        (float[4][4])
+        {
+            {  0.771302711132012,  1.587542278361995, -2.003075114445104, -0.592574156227379 },
+            { -1.208929259769431, -0.786598967848473,  0.607335305808052, -0.154759693303324 },
+            { -1.500037668208218, -0.774300278997914,  1.917800427261255, -0.123268572651291 },
+            { -0.121314770937944,  0.916925149209746, -0.935924950785014,  0.260875394250671 }
+        }
+    );
+
+    Math::Matrix inverse2 = mat2.Inverse();
+
+    if (! Math::MatricesEqual(inverse2, expectedInverse2, TEST_TOLERANCE))
     {
-      {  0.771302711132012,  1.587542278361995, -2.003075114445104, -0.592574156227379 },
-      { -1.208929259769431, -0.786598967848473,  0.607335305808052, -0.154759693303324 },
-      { -1.500037668208218, -0.774300278997914,  1.917800427261255, -0.123268572651291 },
-      { -0.121314770937944,  0.916925149209746, -0.935924950785014,  0.260875394250671 }
+        fprintf(stderr, "Inverse 2 mismatch!\n");
+        return __LINE__;
     }
-  );
 
-  Math::Matrix inverse2 = mat2.Inverse();
-
-  if (! Math::MatricesEqual(inverse2, expectedInverse2, TEST_TOLERANCE))
-  {
-    fprintf(stderr, "Inverse 2 mismatch!\n");
-    return __LINE__;
-  }
-
-  return 0;
+    return 0;
 }
 
 int TestMultiply()
 {
-  const Math::Matrix mat1A(
-    (float[4][4])
-    {
-      {  0.6561727049162027, -1.4180263627131411, -0.8271026046117423,  2.3919331748512578 },
-      { -0.6035665535146352,  0.0150827348790615, -0.7090794192822540,  0.9057604704594814 },
-      { -0.9871045001223655, -0.4980646811455065,  0.3806177002298990,  0.1520583649240934 },
-      { -0.2721911170792712,  0.7627928194552067, -0.1504091336784158,  0.9747545351840121 }
-    }
-  );
-
-  const Math::Matrix mat1B(
-    (float[4][4])
-    {
-      { -0.2643735892448818, -0.7542994492819621,  0.6082322350568750,  0.0581733424861419 },
-      {  1.0293246070431237,  0.1979285388251341, -0.2932031385332818,  0.8838407179018929 },
-      {  0.3448687251553114,  0.5031654871245456,  0.7554693012922442, -0.4845315903845708 },
-      { -1.8662838497278593, -0.7843850624747805,  0.1389026096476257, -1.3686415408300689 }
-    }
-  );
-
-  const Math::Matrix expectedMultiply1(
-    (float[4][4])
-    {
-      { -6.382352236417988, -3.067984733682130,  0.522270304251466, -4.088079444498280 },
-      { -1.759853366848825, -0.608994052024491, -0.781406179437379, -0.917870775786188 },
-      { -0.404226802169062,  0.718232546720114, -0.145688356880835, -0.890167707987175 },
-      { -1.013918490922430, -0.483971504099758, -0.367442194643757, -0.602858486133615 }
-    }
-  );
-
-  Math::Matrix multiply1 = Math::MultiplyMatrices(mat1A, mat1B);
-  if (! Math::MatricesEqual(multiply1, expectedMultiply1, TEST_TOLERANCE ) )
-  {
-    fprintf(stderr, "Multiply 1 mismath!\n");
-    return __LINE__;
-  }
-
-  const Math::Matrix mat2A(
-    (float[4][4])
+    const Math::Matrix mat1A(
+        (float[4][4])
+        {
+            {  0.6561727049162027, -1.4180263627131411, -0.8271026046117423,  2.3919331748512578 },
+            { -0.6035665535146352,  0.0150827348790615, -0.7090794192822540,  0.9057604704594814 },
+            { -0.9871045001223655, -0.4980646811455065,  0.3806177002298990,  0.1520583649240934 },
+            { -0.2721911170792712,  0.7627928194552067, -0.1504091336784158,  0.9747545351840121 }
+        }
+    );
+
+    const Math::Matrix mat1B(
+        (float[4][4])
+        {
+            { -0.2643735892448818, -0.7542994492819621,  0.6082322350568750,  0.0581733424861419 },
+            {  1.0293246070431237,  0.1979285388251341, -0.2932031385332818,  0.8838407179018929 },
+            {  0.3448687251553114,  0.5031654871245456,  0.7554693012922442, -0.4845315903845708 },
+            { -1.8662838497278593, -0.7843850624747805,  0.1389026096476257, -1.3686415408300689 }
+        }
+    );
+
+    const Math::Matrix expectedMultiply1(
+        (float[4][4])
+        {
+            { -6.382352236417988, -3.067984733682130,  0.522270304251466, -4.088079444498280 },
+            { -1.759853366848825, -0.608994052024491, -0.781406179437379, -0.917870775786188 },
+            { -0.404226802169062,  0.718232546720114, -0.145688356880835, -0.890167707987175 },
+            { -1.013918490922430, -0.483971504099758, -0.367442194643757, -0.602858486133615 }
+        }
+    );
+
+    Math::Matrix multiply1 = Math::MultiplyMatrices(mat1A, mat1B);
+    if (! Math::MatricesEqual(multiply1, expectedMultiply1, TEST_TOLERANCE ) )
     {
-      {  0.8697203025776754,  2.1259475710644935,  1.7856691009707812, -2.1563963348328126 },
-      {  1.5888074489288735, -0.0794849733953615,  0.7307782768677457,  0.7943129159612630 },
-      {  0.2859761537233830, -0.6231231890384962, -0.0496743172880377, -0.8137857518646087 },
-      {  1.2670547229512983, -0.5305171374831831, -0.4987412674062375, -1.1257327113869595 }
-    }
-  );
-
-  const Math::Matrix mat2B(
-    (float[4][4])
-    {
-      {  1.1321105701165317,  0.1759563504574463, -2.0675778912000418,  1.4840339814245538 },
-      { -1.5117280888829916, -0.0933013188828093, -0.2079262944351640,  0.9575727579539316 },
-      {  0.3615378398970173,  1.2465163589027248,  1.1326150997082589,  0.9921208694352303 },
-      { -0.7357104529373861, -0.4774022005969588, -0.2118739096676499,  1.1427567093270703 }
+        fprintf(stderr, "Multiply 1 mismath!\n");
+        return __LINE__;
     }
-  );
 
-  const Math::Matrix expectedMultiply2(
-    (float[4][4])
+    const Math::Matrix mat2A(
+        (float[4][4])
+        {
+            {  0.8697203025776754,  2.1259475710644935,  1.7856691009707812, -2.1563963348328126 },
+            {  1.5888074489288735, -0.0794849733953615,  0.7307782768677457,  0.7943129159612630 },
+            {  0.2859761537233830, -0.6231231890384962, -0.0496743172880377, -0.8137857518646087 },
+            {  1.2670547229512983, -0.5305171374831831, -0.4987412674062375, -1.1257327113869595 }
+        }
+    );
+
+    const Math::Matrix mat2B(
+        (float[4][4])
+        {
+            {  1.1321105701165317,  0.1759563504574463, -2.0675778912000418,  1.4840339814245538 },
+            { -1.5117280888829916, -0.0933013188828093, -0.2079262944351640,  0.9575727579539316 },
+            {  0.3615378398970173,  1.2465163589027248,  1.1326150997082589,  0.9921208694352303 },
+            { -0.7357104529373861, -0.4774022005969588, -0.2118739096676499,  1.1427567093270703 }
+        }
+    );
+
+    const Math::Matrix expectedMultiply2(
+        (float[4][4])
+        {
+            {  0.00283516267056338,  3.21001319965989307,  0.23910503934370686,  2.63380716363006107 },
+            {  1.59868505822469742,  0.81869715594617765, -2.60905981088293570,  3.91445839239110294 },
+            {  1.84650099286297942,  0.43504079532852930, -0.34555619012424243, -1.15152951542451487 },
+            {  2.88434318563174585,  0.18818239851585700, -2.83579436909308980, -0.40890672198610400 }
+        }
+    );
+
+    Math::Matrix multiply2 = Math::MultiplyMatrices(mat2A, mat2B);
+    if (! Math::MatricesEqual(multiply2, expectedMultiply2, TEST_TOLERANCE ) )
     {
-      {  0.00283516267056338,  3.21001319965989307,  0.23910503934370686,  2.63380716363006107 },
-      {  1.59868505822469742,  0.81869715594617765, -2.60905981088293570,  3.91445839239110294 },
-      {  1.84650099286297942,  0.43504079532852930, -0.34555619012424243, -1.15152951542451487 },
-      {  2.88434318563174585,  0.18818239851585700, -2.83579436909308980, -0.40890672198610400 }
+        fprintf(stderr, "Multiply 2 mismath!\n");
+        return __LINE__;
     }
-  );
-
-  Math::Matrix multiply2 = Math::MultiplyMatrices(mat2A, mat2B);
-  if (! Math::MatricesEqual(multiply2, expectedMultiply2, TEST_TOLERANCE ) )
-  {
-    fprintf(stderr, "Multiply 2 mismath!\n");
-    return __LINE__;
-  }
 
-  return 0;
+    return 0;
 }
 
 int TestMultiplyVector()
 {
-  const Math::Matrix mat1(
-    (float[4][4])
+    const Math::Matrix mat1(
+        (float[4][4])
+        {
+            {  0.188562846910008, -0.015148651460679,  0.394512304108827,  0.906910631257135 },
+            { -0.297506779519667,  0.940119328178913,  0.970957796752517,  0.310559318965526 },
+            { -0.819770525290873, -2.316574438778879,  0.155756069319732, -0.855661405742964 },
+            {  0.000000000000000,  0.000000000000000,  0.000000000000000,  1.000000000000000 }
+        }
+    );
+
+    const Math::Vector vec1(-0.824708565156661, -1.598287748103842, -0.422498044734181);
+
+    const Math::Vector expectedMultiply1(0.608932463260470, -1.356893266403749, 3.457156276255142);
+
+    Math::Vector multiply1 = Math::MatrixVectorMultiply(mat1, vec1, false);
+    if (! Math::VectorsEqual(multiply1, expectedMultiply1, TEST_TOLERANCE ) )
     {
-      {  0.188562846910008, -0.015148651460679,  0.394512304108827,  0.906910631257135 },
-      { -0.297506779519667,  0.940119328178913,  0.970957796752517,  0.310559318965526 },
-      { -0.819770525290873, -2.316574438778879,  0.155756069319732, -0.855661405742964 },
-      {  0.000000000000000,  0.000000000000000,  0.000000000000000,  1.000000000000000 }
+        fprintf(stderr, "Multiply vector 1 mismath!\n");
+        return __LINE__;
     }
-  );
 
-  const Math::Vector vec1(-0.824708565156661, -1.598287748103842, -0.422498044734181);
+    const Math::Matrix mat2(
+        (float[4][4])
+        {
+            { -0.63287117038834284,  0.55148060401816856, -0.02042395559467368, -1.50367083897656850 },
+            {  0.69629042156335297,  0.12982747869796774, -1.16250029235919405,  1.19084447253756909 },
+            {  0.44164132914357224, -0.15169304045662041, -0.00880583574621390, -0.55817802940035310 },
+            {  0.95680476533530789, -1.51912346889253125, -0.74209769406615944, -0.20938988867903682 }
+        }
+    );
 
-  const Math::Vector expectedMultiply1(0.608932463260470, -1.356893266403749, 3.457156276255142);
+    const Math::Vector vec2(0.330987381051962, 1.494375516393466, 1.483422335561857);
 
-  Math::Vector multiply1 = Math::MatrixVectorMultiply(mat1, vec1, false);
-  if (! Math::VectorsEqual(multiply1, expectedMultiply1, TEST_TOLERANCE ) )
-  {
-    fprintf(stderr, "Multiply vector 1 mismath!\n");
-    return __LINE__;
-  }
+    const Math::Vector expectedMultiply2(0.2816820577317669, 0.0334468811767428, 0.1996974284970455);
 
-  const Math::Matrix mat2(
-    (float[4][4])
+    Math::Vector multiply2 = Math::MatrixVectorMultiply(mat2, vec2, true);
+    if (! Math::VectorsEqual(multiply2, expectedMultiply2, TEST_TOLERANCE ) )
     {
-      { -0.63287117038834284,  0.55148060401816856, -0.02042395559467368, -1.50367083897656850 },
-      {  0.69629042156335297,  0.12982747869796774, -1.16250029235919405,  1.19084447253756909 },
-      {  0.44164132914357224, -0.15169304045662041, -0.00880583574621390, -0.55817802940035310 },
-      {  0.95680476533530789, -1.51912346889253125, -0.74209769406615944, -0.20938988867903682 }
+        fprintf(stderr, "Multiply vector 2 mismath!\n");
+        return __LINE__;
     }
-  );
 
-  const Math::Vector vec2(0.330987381051962, 1.494375516393466, 1.483422335561857);
-
-  const Math::Vector expectedMultiply2(0.2816820577317669, 0.0334468811767428, 0.1996974284970455);
-
-  Math::Vector multiply2 = Math::MatrixVectorMultiply(mat2, vec2, true);
-  if (! Math::VectorsEqual(multiply2, expectedMultiply2, TEST_TOLERANCE ) )
-  {
-    fprintf(stderr, "Multiply vector 2 mismath!\n");
-    return __LINE__;
-  }
-
-  return 0;
+    return 0;
 }
 
 int main()
 {
-  // Functions to test
-  int (*TESTS[])() =
-  {
-    TestTranspose,
-    TestCofactor,
-    TestDet,
-    TestInverse,
-    TestMultiply,
-    TestMultiplyVector
-  };
-  const int TESTS_SIZE = sizeof(TESTS) / sizeof(*TESTS);
-
-  int result = 0;
-  for (int i = 0; i < TESTS_SIZE; ++i)
-  {
-    result = TESTS[i]();
-    if (result != 0)
-      return result;
-  }
-
-  fprintf(stderr, "All tests successful\n");
-
-  return 0;
+    // Functions to test
+    int (*TESTS[])() =
+    {
+        TestTranspose,
+        TestCofactor,
+        TestDet,
+        TestInverse,
+        TestMultiply,
+        TestMultiplyVector
+    };
+    const int TESTS_SIZE = sizeof(TESTS) / sizeof(*TESTS);
+
+    int result = 0;
+    for (int i = 0; i < TESTS_SIZE; ++i)
+    {
+        result = TESTS[i]();
+        if (result != 0)
+            return result;
+    }
+
+    fprintf(stderr, "All tests successful\n");
+
+    return 0;
 }
 
diff --git a/src/math/test/vector_test.cpp b/src/math/test/vector_test.cpp
index d2bf231..899a580 100644
--- a/src/math/test/vector_test.cpp
+++ b/src/math/test/vector_test.cpp
@@ -16,11 +16,11 @@
 
 // math/test/vector_test.cpp
 
-/* Unit tests for Vector struct
-
-   Test data was randomly generated and the expected results
-   calculated using GNU Octave.
+/*
+  Unit tests for Vector struct
 
+  Test data was randomly generated and the expected results
+  calculated using GNU Octave.
  */
 
 #include "../func.h"
@@ -34,94 +34,94 @@ const float TEST_TOLERANCE = 1e-6;
 
 int TestLength()
 {
-  Math::Vector vec(-1.288447945923275, 0.681452565308134, -0.633761098985957);
-  const float expectedLength = 1.58938001708428;
+    Math::Vector vec(-1.288447945923275, 0.681452565308134, -0.633761098985957);
+    const float expectedLength = 1.58938001708428;
 
-  if (! Math::IsEqual(vec.Length(), expectedLength, TEST_TOLERANCE) )
-  {
-    fprintf(stderr, "Length mismatch!\n");
-    return __LINE__;
-  }
+    if (! Math::IsEqual(vec.Length(), expectedLength, TEST_TOLERANCE) )
+    {
+        fprintf(stderr, "Length mismatch!\n");
+        return __LINE__;
+    }
 
-  return 0;
+    return 0;
 }
 
 int TestNormalize()
 {
-  Math::Vector vec(1.848877241804398, -0.157262961268577, -1.963031403332377);
-  const Math::Vector expectedNormalized(0.6844609421393856, -0.0582193085618106, -0.7267212194481797);
+    Math::Vector vec(1.848877241804398, -0.157262961268577, -1.963031403332377);
+    const Math::Vector expectedNormalized(0.6844609421393856, -0.0582193085618106, -0.7267212194481797);
 
-  vec.Normalize();
+    vec.Normalize();
 
-  if (! Math::VectorsEqual(vec, expectedNormalized, TEST_TOLERANCE))
-  {
-    fprintf(stderr, "Normalize mismatch!\n");
-    return __LINE__;
-  }
+    if (! Math::VectorsEqual(vec, expectedNormalized, TEST_TOLERANCE))
+    {
+        fprintf(stderr, "Normalize mismatch!\n");
+        return __LINE__;
+    }
 
-  return 0;
+    return 0;
 }
 
 int TestDot()
 {
-  Math::Vector vecA(0.8202190530968309, 0.0130926060162780, 0.2411914183883510);
-  Math::Vector vecB(-0.0524083951404069, 1.5564932716738220, -0.8971342631500536);
+    Math::Vector vecA(0.8202190530968309, 0.0130926060162780, 0.2411914183883510);
+    Math::Vector vecB(-0.0524083951404069, 1.5564932716738220, -0.8971342631500536);
 
-  float expectedDot = -0.238988896477326;
+    float expectedDot = -0.238988896477326;
 
-  if (! Math::IsEqual(Math::DotProduct(vecA, vecB), expectedDot, TEST_TOLERANCE) )
-  {
-    fprintf(stderr, "Dot product mismatch!\n");
-    return __LINE__;
-  }
+    if (! Math::IsEqual(Math::DotProduct(vecA, vecB), expectedDot, TEST_TOLERANCE) )
+    {
+        fprintf(stderr, "Dot product mismatch!\n");
+        return __LINE__;
+    }
 
-  return 0;
+    return 0;
 }
 
 int TestCross()
 {
-  Math::Vector vecA(1.37380499798567, 1.18054518384682, 1.95166361293121);
-  Math::Vector vecB(0.891657855926886, 0.447591335394532, -0.901604070087823);
+    Math::Vector vecA(1.37380499798567, 1.18054518384682, 1.95166361293121);
+    Math::Vector vecB(0.891657855926886, 0.447591335394532, -0.901604070087823);
 
-  Math::Vector expectedCross(-1.937932065431669, 2.978844370287636, -0.437739173833581);
-  Math::Vector expectedReverseCross = -expectedCross;
+    Math::Vector expectedCross(-1.937932065431669, 2.978844370287636, -0.437739173833581);
+    Math::Vector expectedReverseCross = -expectedCross;
 
-  if (! Math::VectorsEqual(vecA.CrossMultiply(vecB), expectedCross, TEST_TOLERANCE) )
-  {
-    fprintf(stderr, "Cross product mismatch!\n");
-    return __LINE__;
-  }
+    if (! Math::VectorsEqual(vecA.CrossMultiply(vecB), expectedCross, TEST_TOLERANCE) )
+    {
+        fprintf(stderr, "Cross product mismatch!\n");
+        return __LINE__;
+    }
 
-  if (! Math::VectorsEqual(vecB.CrossMultiply(vecA), expectedReverseCross, TEST_TOLERANCE) )
-  {
-    fprintf(stderr, "Reverse cross product mismatch!\n");
-    return __LINE__;
-  }
+    if (! Math::VectorsEqual(vecB.CrossMultiply(vecA), expectedReverseCross, TEST_TOLERANCE) )
+    {
+        fprintf(stderr, "Reverse cross product mismatch!\n");
+        return __LINE__;
+    }
 
-  return 0;
+    return 0;
 }
 
 int main()
 {
-  // Functions to test
-  int (*TESTS[])() =
-  {
-    TestLength,
-    TestNormalize,
-    TestDot,
-    TestCross
-  };
-  const int TESTS_SIZE = sizeof(TESTS) / sizeof(*TESTS);
-
-  int result = 0;
-  for (int i = 0; i < TESTS_SIZE; ++i)
-  {
-    result = TESTS[i]();
-    if (result != 0)
-      return result;
-  }
-
-  fprintf(stderr, "All tests successful\n");
-
-  return 0;
+    // Functions to test
+    int (*TESTS[])() =
+    {
+        TestLength,
+        TestNormalize,
+        TestDot,
+        TestCross
+    };
+    const int TESTS_SIZE = sizeof(TESTS) / sizeof(*TESTS);
+
+    int result = 0;
+    for (int i = 0; i < TESTS_SIZE; ++i)
+    {
+        result = TESTS[i]();
+        if (result != 0)
+            return result;
+    }
+
+    fprintf(stderr, "All tests successful\n");
+
+    return 0;
 }