Renamed Vector3d to Vec3, added math unit test

ChangeLog.md

@@ -2,6 +2,10 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141203 ]
+    * Renamed Vector3d to Vec3, small cleanup
+    * Added preliminary math unit test
+
     [ 20141202 ]
     * No longer crashing when LoaderTR2 does not find an SFX file
     * LoaderTR2 now loads level-wide Sprites (no Room Sprites yet)

include/Sprite.h

@@ -21,10 +21,10 @@ class Sprite {
 
     Sprite(TombRaider& tr, unsigned int item, unsigned int sequence, unsigned int index) :
         Sprite((tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->tile,
-        (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->x,
-        (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->y,
-        (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->width,
-        (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->height) { }
+               (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->x,
+               (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->y,
+               (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->width,
+               (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->height) { }
 
     void display();
     void display(float x, float y, float w, float h);

include/math/Matrix.h

@@ -10,7 +10,7 @@
 
 #include "math/math.h"
 #include "math/Quaternion.h"
-#include "math/Vector3d.h"
+#include "math/Vec3.h"
 
 
 /*!
@@ -117,7 +117,7 @@ class Matrix {
      * \param v Vector to multiply with
      * \returns resultant vector (mult)
      */
-    Vector3d operator *(Vector3d v);
+    Vec3 operator *(Vec3 v);
 
     /*!
      * \brief Sets to identity matrix

include/math/Vec3.h

@@ -0,0 +1,46 @@
+/*!
+ * \file include/math/Vec3.h
+ * \brief 3D Math vector
+ *
+ * \author xythobuz
+ * \author Mongoose
+ */
+
+#ifndef _MATH_VEC3_H_
+#define _MATH_VEC3_H_
+
+#include "math/math.h"
+
+class Vec3 {
+  public:
+    Vec3(float _x = 0.0f, float _y = 0.0f, float _z = 0.0f);
+    Vec3(float v[3]);
+
+    float magnitude();
+    void normalize();
+    Vec3 unit();
+
+    Vec3 operator +(const Vec3& v);
+    Vec3 operator -(const Vec3& v);
+    Vec3 operator -();
+    Vec3 operator *(float s);
+    Vec3 operator /(float s);
+    float operator *(const Vec3& v);
+
+    Vec3& operator +=(const Vec3& v);
+    Vec3& operator -=(const Vec3& v);
+    Vec3& operator *=(float s);
+
+    bool operator ==(const Vec3& v);
+    bool operator !=(const Vec3& v);
+
+    float x, y, z;
+
+    // ----------------------------------------------------------
+
+    static float dot(const Vec3& u, const Vec3& v);
+    static Vec3 cross(const Vec3& u, const Vec3& v);
+};
+
+#endif
+

include/math/Vector3d.h

@@ -1,161 +0,0 @@
-/*!
- * \file include/math/Vector3d.h
- * \brief 3D Math vector
- *
- * \author Mongoose
- */
-
-#ifndef _MATH_VECTOR3D_H_
-#define _MATH_VECTOR3D_H_
-
-#include "math/math.h"
-
-/*!
- * \brief 3D Math Vector
- */
-class Vector3d {
-  public:
-
-    /*!
-     * \brief Constructs an object of Vector3d
-     */
-    Vector3d();
-
-    /*!
-     * \brief Constructs an object of Vector3d
-     * \param v data to load into new Vector3d
-     */
-    Vector3d(float v[3]);
-
-    /*!
-     * \brief Constructs an object of Vector3d
-     * \param x X part of new Vector3d
-     * \param y Y part of new Vector3d
-     * \param z Z part of new Vector3d
-     */
-    Vector3d(float x, float y, float z);
-
-    /*!
-     * \brief Constructs an object of Vector3d
-     * \param v contents of new Vector3d
-     */
-    Vector3d(const Vector3d& v);
-
-    /*!
-     * \brief Calculate dot product
-     * \param u first argument
-     * \param v second argument
-     * \returns dot product of u and v vectors
-     */
-    static float dot(const Vector3d& u, const Vector3d& v);
-
-    /*!
-     * \brief Calculate cross product
-     * \param u first argument
-     * \param v second argument
-     * \returns cross product of u and v vectors
-     */
-    static Vector3d cross(const Vector3d& u, const Vector3d& v);
-
-    /*!
-     * \brief Get Magnitude
-     * \returns magnitude of this vector
-     */
-    float magnitude();
-
-    /*!
-     * \brief Normalize
-     * \returns normalized copy of this vector
-     */
-    Vector3d unit();
-
-    /*!
-     * \brief Get the Zero vector
-     * \returns (0, 0, 0) vector
-     */
-    static Vector3d zeroVector();
-
-    /*!
-     * \brief Add to this vector
-     * \param v addend
-     * \returns a vector = this vector + v
-     */
-    Vector3d operator +(const Vector3d& v);
-
-    /*!
-     * \brief Subtract from this vector
-     * \param v subtrahend
-     * \returns a vector = this vector - v
-     */
-    Vector3d operator -(const Vector3d& v);
-
-    /*!
-     * \brief Negate this vector
-     * \returns a copy of this vector, negated
-     */
-    Vector3d operator -();
-
-    /*!
-     * \brief Scale this vector
-     * \param s scaling factor
-     * \returns this vector multiplied with s
-     */
-    Vector3d operator *(float s);
-
-    /*!
-     * \brief Scale this vactor
-     * \param s inverse scaling factor
-     * \returns this vector divided by s
-     */
-    Vector3d operator /(float s);
-
-    /*!
-     * \brief Dot product this vector
-     * \param v second vector for dot product
-     * \returns dot product of V by this vector
-     */
-    float operator *(const Vector3d& v);
-
-    /*!
-     * \brief Normalizes this vector
-     */
-    void normalize();
-
-    /*!
-     * \brief Set this vector to Zero (0, 0, 0)
-     */
-    void zero();
-
-    /*!
-     * \brief Set this vector
-     * \param v what this vector will be set to
-     * \returns this vector, now equal to v
-     */
-    Vector3d& operator =(const Vector3d& v);
-
-    /*!
-     * \brief Add to this vector, in place
-     * \param v what will be added to this vector
-     * \returns this vector, with v added
-     */
-    Vector3d& operator +=(const Vector3d& v);
-
-    /*!
-     * \brief Subtract from this vector, in place
-     * \param v what will be subtracted from this vector
-     * \returns this vector, with v subtracted
-     */
-    Vector3d& operator -=(const Vector3d& v);
-
-    /*!
-     * \brief Scale this vector, in place
-     * \param s scaling factor
-     * \returns this vactor multiplied by s
-     */
-    Vector3d& operator *=(float s);
-
-    float mVec[3]; //!< Vector data
-};
-
-#endif
-

src/Render.cpp

@@ -562,7 +562,8 @@ void Render::debugDisplaySprite(int sprite, int offset, float x, float y, float
     debugTextile = -1;
 }
 
-void Render::drawSprite(float x, float y, float w, float h, unsigned int sprite, unsigned int offset) {
+void Render::drawSprite(float x, float y, float w, float h, unsigned int sprite,
+                        unsigned int offset) {
     glColor3ubv(WHITE);
 
     if (mFlags & Render::fGL_Lights)

src/loader/LoaderTR2.cpp

@@ -694,7 +694,7 @@ void LoaderTR2::loadBoxesOverlapsZones() {
     // TODO store zones somewhere
 
     if ((numBoxes > 0) || (numOverlaps > 0))
-        getLog() << "LoaderTR2: Found NPC NavigationHints, not yet implemented!" << Log::endl;
+        getLog() << "LoaderTR2: Found NPC NavigationHints, unimplemented!" << Log::endl;
 }
 
 // ---- Sound ----
@@ -800,7 +800,7 @@ void LoaderTR2::loadExternalSoundFile(std::string f) {
     }
 
     if (riffCount > 0)
-        getLog() << "LoaderTR2: Found " << riffCount << " SoundSamples" << Log::endl;
+        getLog() << "LoaderTR2: Found " << riffCount << " SoundSamples in SFX" << Log::endl;
 }
 
 // ---- Stuff ----
@@ -839,7 +839,7 @@ void LoaderTR2::loadCinematicFrames() {
 
     if (numCinematicFrames > 0)
         getLog() << "LoaderTR2: Found " << numCinematicFrames
-                 << " CinematicFrames, not yet implemented!" << Log::endl;
+                 << " CinematicFrames, unimplemented!" << Log::endl;
 }
 
 void LoaderTR2::loadDemoData() {
@@ -849,7 +849,7 @@ void LoaderTR2::loadDemoData() {
 
     // TODO store demo data somewhere, find out meaning
     if (numDemoData > 0)
-        getLog() << "LoaderTR2: Found " << numDemoData << " bytes DemoData, not yet implemented!" <<
+        getLog() << "LoaderTR2: Found " << numDemoData << " bytes DemoData, unimplemented!" <<
                  Log::endl;
 }
 

src/math/CMakeLists.txt

@@ -2,7 +2,7 @@
 set (MATH_SRCS ${MATH_SRCS} "math.cpp")
 set (MATH_SRCS ${MATH_SRCS} "Matrix.cpp")
 set (MATH_SRCS ${MATH_SRCS} "Quaternion.cpp")
-set (MATH_SRCS ${MATH_SRCS} "Vector3d.cpp")
+set (MATH_SRCS ${MATH_SRCS} "Vec3.cpp")
 
 # Add library
 add_library (OpenRaider_math OBJECT ${MATH_SRCS})

src/math/Matrix.cpp

@@ -177,17 +177,17 @@ Matrix Matrix::operator *(const Matrix& a) {
     return multiply(a, *this);
 }
 
-Vector3d Matrix::operator *(Vector3d v) {
-    float x = v.mVec[0], y = v.mVec[1], z = v.mVec[2];
+Vec3 Matrix::operator *(Vec3 v) {
+    float x = v.x, y = v.y, z = v.z;
 
 #ifdef COLUMN_ORDER
-    return Vector3d(mMatrix[0] * x + mMatrix[4] * y + mMatrix[ 8] * z + mMatrix[12],
-                    mMatrix[1] * x + mMatrix[5] * y + mMatrix[ 9] * z + mMatrix[13],
-                    mMatrix[2] * x + mMatrix[6] * y + mMatrix[10] * z + mMatrix[14]);
+    return Vec3(mMatrix[0] * x + mMatrix[4] * y + mMatrix[ 8] * z + mMatrix[12],
+                mMatrix[1] * x + mMatrix[5] * y + mMatrix[ 9] * z + mMatrix[13],
+                mMatrix[2] * x + mMatrix[6] * y + mMatrix[10] * z + mMatrix[14]);
 #else
-    return Vector3d(mMatrix[0] * x + mMatrix[1] * y + mMatrix[ 2] * z + mMatrix[ 3],
-                    mMatrix[4] * x + mMatrix[5] * y + mMatrix[ 6] * z + mMatrix[ 7],
-                    mMatrix[8] * x + mMatrix[9] * y + mMatrix[10] * z + mMatrix[11]);
+    return Vec3(mMatrix[0] * x + mMatrix[1] * y + mMatrix[ 2] * z + mMatrix[ 3],
+                mMatrix[4] * x + mMatrix[5] * y + mMatrix[ 6] * z + mMatrix[ 7],
+                mMatrix[8] * x + mMatrix[9] * y + mMatrix[10] * z + mMatrix[11]);
 #endif
 }
 

src/math/Vec3.cpp

@@ -0,0 +1,118 @@
+/*!
+ * \file src/math/Vec3.cpp
+ * \brief 3D Math vector
+ *
+ * \author Mongoose
+ */
+
+#include <math.h>
+
+#include "global.h"
+#include "math/Vec3.h"
+
+Vec3::Vec3(float _x, float _y, float _z) {
+    x = _x;
+    y = _y;
+    z = _z;
+}
+
+Vec3::Vec3(float v[3]) {
+    assert(v != nullptr);
+    x = v[0];
+    y = v[1];
+    z = v[2];
+}
+
+float Vec3::magnitude() {
+    return sqrtf(x * x + y * y + z * z);
+}
+
+void Vec3::normalize() {
+    float norm = magnitude();
+    x /= norm;
+    y /= norm;
+    z /= norm;
+}
+
+Vec3 Vec3::unit() {
+    float norm = magnitude();
+    return Vec3(x / norm,
+                y / norm,
+                z / norm);
+}
+
+Vec3 Vec3::operator +(const Vec3& v) {
+    return Vec3(x + v.x,
+                y + v.y,
+                z + v.z);
+}
+
+Vec3 Vec3::operator -(const Vec3& v) {
+    return Vec3(x - v.x,
+                y - v.y,
+                z - v.z);
+}
+
+Vec3 Vec3::operator -() {
+    return Vec3(-x,
+                -y,
+                -z);
+}
+
+Vec3 Vec3::operator *(float s) {
+    return Vec3(s * x,
+                s * y,
+                s * z);
+}
+
+Vec3 Vec3::operator /(float s) {
+    return Vec3(x / s,
+                y / s,
+                z / s);
+}
+
+float Vec3::operator *(const Vec3& v) {
+    return dot(*this, v);
+}
+
+Vec3& Vec3::operator +=(const Vec3& v) {
+    x += v.x;
+    y += v.y;
+    z += v.z;
+    return *this;
+}
+
+Vec3& Vec3::operator -=(const Vec3& v) {
+    x -= v.x;
+    y -= v.y;
+    z -= v.z;
+    return *this;
+}
+
+Vec3& Vec3::operator *=(float s) {
+    x *= s;
+    y *= s;
+    z *= s;
+    return *this;
+}
+
+bool Vec3::operator ==(const Vec3& v) {
+    return equalEpsilon(x, v.x)
+        && equalEpsilon(y, v.y)
+        && equalEpsilon(z, v.z);
+}
+
+bool Vec3::operator !=(const Vec3& v) {
+    return !((*this) == v);
+}
+
+float Vec3::dot(const Vec3& u, const Vec3& v) {
+    return (u.x * v.x + u.y * v.y + u.z * v.z);
+}
+
+Vec3 Vec3::cross(const Vec3& u, const Vec3& v) {
+    return Vec3(u.y * v.z - u.z * v.y,
+                u.z * v.x - u.x * v.z,
+                u.x * v.y - u.y * v.x);
+}
+

src/math/Vector3d.cpp

@@ -1,136 +0,0 @@
-/*!
- * \file src/math/Vector3d.cpp
- * \brief 3D Math vector
- *
- * \author Mongoose
- */
-
-#include <math.h>
-
-#include "global.h"
-#include "math/Vector3d.h"
-
-Vector3d::Vector3d() {
-    mVec[0] = mVec[1] = mVec[2] = 0.0f;
-}
-
-Vector3d::Vector3d(float v[3]) {
-    mVec[0] = v[0];
-    mVec[1] = v[1];
-    mVec[2] = v[2];
-}
-
-Vector3d::Vector3d(float x, float y, float z) {
-    mVec[0] = x;
-    mVec[1] = y;
-    mVec[2] = z;
-}
-
-Vector3d::Vector3d(const Vector3d& v) {
-    mVec[0] = v.mVec[0];
-    mVec[1] = v.mVec[1];
-    mVec[2] = v.mVec[2];
-}
-
-float Vector3d::dot(const Vector3d& u, const Vector3d& v) {
-    return (u.mVec[0] * v.mVec[0] + u.mVec[1] * v.mVec[1] + u.mVec[2] * v.mVec[2]);
-}
-
-Vector3d Vector3d::cross(const Vector3d& u, const Vector3d& v) {
-    return Vector3d(u.mVec[1] * v.mVec[2] - u.mVec[2] * v.mVec[1],
-                    u.mVec[2] * v.mVec[0] - u.mVec[0] * v.mVec[2],
-                    u.mVec[0] * v.mVec[1] - u.mVec[1] * v.mVec[0]);
-}
-
-float Vector3d::magnitude() {
-    return sqrtf(mVec[0] * mVec[0] + mVec[1] * mVec[1] + mVec[2] * mVec[2]);
-}
-
-Vector3d Vector3d::unit() {
-    float norm = magnitude();
-
-    return Vector3d(mVec[0] / norm,
-                    mVec[1] / norm,
-                    mVec[2] / norm);
-}
-
-Vector3d Vector3d::zeroVector() {
-    return Vector3d(0, 0, 0);
-}
-
-Vector3d Vector3d::operator +(const Vector3d& v) {
-    return Vector3d(mVec[0] + v.mVec[0],
-                    mVec[1] + v.mVec[1],
-                    mVec[2] + v.mVec[2]);
-}
-
-Vector3d Vector3d::operator -(const Vector3d& v) {
-    return Vector3d(mVec[0] - v.mVec[0],
-                    mVec[1] - v.mVec[1],
-                    mVec[2] - v.mVec[2]);
-}
-
-Vector3d Vector3d::operator -() {
-    return Vector3d(-mVec[0],
-                    -mVec[1],
-                    -mVec[2]);
-}
-
-Vector3d Vector3d::operator *(float s) {
-    return Vector3d(s * mVec[0],
-                    s * mVec[1],
-                    s * mVec[2]);
-}
-
-Vector3d Vector3d::operator /(float s) {
-    return Vector3d(mVec[0] / s,
-                    mVec[1] / s,
-                    mVec[2] / s);
-}
-
-float Vector3d::operator *(const Vector3d& v) {
-    return dot(*this, v);
-}
-
-void Vector3d::normalize() {
-    float norm = magnitude();
-
-    mVec[0] /= norm;
-    mVec[1] /= norm;
-    mVec[2] /= norm;
-}
-
-void Vector3d::zero() {
-    mVec[0] = 0;
-    mVec[1] = 0;
-    mVec[2] = 0;
-}
-
-Vector3d& Vector3d::operator =(const Vector3d& v) {
-    mVec[0] = v.mVec[0];
-    mVec[1] = v.mVec[1];
-    mVec[2] = v.mVec[2];
-    return *this;
-}
-
-Vector3d& Vector3d::operator +=(const Vector3d& v) {
-    mVec[0] += v.mVec[0];
-    mVec[1] += v.mVec[1];
-    mVec[2] += v.mVec[2];
-    return *this;
-}
-
-Vector3d& Vector3d::operator -=(const Vector3d& v) {
-    mVec[0] -= v.mVec[0];
-    mVec[1] -= v.mVec[1];
-    mVec[2] -= v.mVec[2];
-    return *this;
-}
-
-Vector3d& Vector3d::operator *=(float s) {
-    mVec[0] *= s;
-    mVec[1] *= s;
-    mVec[2] *= s;
-    return *this;
-}
-

src/math/math.cpp

@@ -13,7 +13,7 @@
 #include <algorithm>
 
 #include "global.h"
-#include "math/Vector3d.h"
+#include "math/Vec3.h"
 #include "math/Matrix.h"
 #include "math/math.h"
 
@@ -29,46 +29,46 @@ int intersectionLinePolygon(float intersect[3],
     assert(polygon != NULL);
 
     // float normal[3], a[3], b[3];
-    Vector3d a, b, normal, pA, pB;
+    Vec3 a, b, normal, pA, pB;
     float d, denominator, mu;
 
 
-    pA = Vector3d(p1);
-    pB = Vector3d(p2);
+    pA = Vec3(p1);
+    pB = Vec3(p2);
 
     // Find normal
-    a = Vector3d(polygon[1]) - Vector3d(polygon[0]);
-    b = Vector3d(polygon[2]) - Vector3d(polygon[0]);
-    normal = Vector3d::cross(a, b);
+    a = Vec3(polygon[1]) - Vec3(polygon[0]);
+    b = Vec3(polygon[2]) - Vec3(polygon[0]);
+    normal = Vec3::cross(a, b);
     normal.normalize();
 
     // find D
-    d = (normal.mVec[0] * polygon[0][0] -
-         normal.mVec[1] * polygon[0][1] -
-         normal.mVec[2] * polygon[0][2]);
+    d = (normal.x * polygon[0][0] -
+         normal.y * polygon[0][1] -
+         normal.z * polygon[0][2]);
 
     // line segment parallel to plane?
     a = pB - pA;
 
-    denominator = Vector3d::dot(normal, a);
+    denominator = Vec3::dot(normal, a);
 
     if (denominator > 0.0)
         return 0;
 
     // Line segment contains intercept point?
-    mu = -((d + Vector3d::dot(normal, pA)) / denominator);
+    mu = -((d + Vec3::dot(normal, pA)) / denominator);
 
     if (mu < 0.0 || mu > 1.0)
         return 0;
 
     b = pA + (a * mu);
-    intersect[0] = b.mVec[0];
-    intersect[1] = b.mVec[1];
-    intersect[2] = b.mVec[2];
+    intersect[0] = b.x;
+    intersect[1] = b.y;
+    intersect[2] = b.z;
 
     // See if the intercept is bound by polygon by winding number
     // assume convex polygons here for sure
-    double theta = Vector3d::dot(b - Vector3d(polygon[0]), normal); // b = intersect
+    double theta = Vec3::dot(b - Vec3(polygon[0]), normal); // b = intersect
 
     if (theta >= 90.0) // Yeah I know
         return 0;

test/CMakeLists.txt

@@ -25,6 +25,15 @@ add_executable (tester_loader EXCLUDE_FROM_ALL
 
 #################################################################
 
+add_executable (tester_math EXCLUDE_FROM_ALL
+    "math.cpp" "../src/math/math.cpp"
+    "../src/math/Vec3.cpp"
+)
+add_dependencies (check tester_math)
+add_test (NAME test_math COMMAND tester_math)
+
+#################################################################
+
 add_executable (tester_script EXCLUDE_FROM_ALL
     "Script.cpp" "../src/Script.cpp" "../src/main.cpp"
     "../src/utils/binary.cpp" "../src/Exception.cpp"

test/math.cpp

@@ -0,0 +1,34 @@
+/*!
+ * \file test/math.cpp
+ * \brief Math Unit Test
+ *
+ * \author xythobuz
+ */
+
+#include <iostream>
+
+#include "global.h"
+#include "math/math.h"
+#include "math/Vec3.h"
+
+#define check(x) if (!(x)) { \
+    std::cout << "Test failed: " << #x << std::endl; \
+    return -1; \
+}
+
+int main() {
+    // math.h
+    check(equalEpsilon(42.23f, 42.23f));
+    check(!equalEpsilon(42.23f, 23.42f));
+
+    // Vec3.h
+    Vec3 a(42.0f, 23.0f, 66.0f);
+    Vec3 b(23.0f, 66.0f, 42.0f);
+    Vec3 result(-3390.0f, -246.0f, 2243.0f);
+    check(Vec3::cross(a, b) == result);
+
+    check(equalEpsilon(a * b, 5256.0f));
+
+    return 0;
+}
+