Slimmed down math/math.h

include/math/math.h

  * \brief Vector and Matrix math
  *
  * \author Mongoose
+ * \author xythobuz
  */
 
 #include <math.h>
 #ifndef _MATH_MATH_H
 #define _MATH_MATH_H
 
-#define HEL_PI           ((float)M_PI) //!< pi
-#define HEL_2_PI         (HEL_PI * 2.0f) //!< pi*2
-#define HEL_PI_OVER_4    (HEL_PI / 4.0f) //!< pi/4
-#define HEL_PI_OVER_180  (HEL_PI / 180.0f) //!< pi/180
-#define HEL_180_OVER_PI  (180.0f / HEL_PI) //!< 180/pi
+#define OR_PI           ((float)M_PI) //!< pi
+#define OR_2_PI         (OR_PI * 2.0f) //!< pi*2
+#define OR_PI_OVER_4    (OR_PI / 4.0f) //!< pi/4
+#define OR_PI_OVER_180  (OR_PI / 180.0f) //!< pi/180
+#define OR_180_OVER_PI  (180.0f / OR_PI) //!< 180/pi
 
-#define HEL_RAD_TO_DEG(x) ((x) * HEL_180_OVER_PI) //!< Convert radians to degrees
-#define HEL_DEG_TO_RAD(x) ((x) * HEL_PI_OVER_180) //!< Convert degrees to radians
+#define OR_RAD_TO_DEG(x) ((x) * OR_180_OVER_PI) //!< Convert radians to degrees
+#define OR_DEG_TO_RAD(x) ((x) * OR_PI_OVER_180) //!< Convert degrees to radians
 
 typedef float vec_t;        //!< 1D Vector, aka float
 typedef float vec2_t[2];    //!< 2D Vector
  * \param polygon polygon vertex array (0 to 2 are used)
  * \returns 0 if there is no intersection
  */
-int helIntersectionLineAndPolygon(vec3_t intersect, vec3_t p1, vec3_t p2, vec3_t *polygon);
+int intersectionLinePolygon(vec3_t intersect, vec3_t p1, vec3_t p2, vec3_t *polygon);
 
 /*!
  * \brief Calculate the length of a line segment / the distance between two points
  * \param b Second point
  * \returns distance/length
  */
-vec_t helDist3v(vec3_t a, vec3_t b);
+vec_t distance(vec3_t a, vec3_t b);
 
 /*!
  * \brief Calculates the midpoint between two points / of a line segment
  * \param b Second point
  * \param mid Midpoint will be stored here
  */
-void helMidpoint3v(vec3_t a, vec3_t b, vec3_t mid);
+void midpoint(vec3_t a, vec3_t b, vec3_t mid);
 
 /*!
  * \brief Calculates a pseudo-random number
  * \param to Upper bound
  * \returns random number
  */
-vec_t helRandomNum(vec_t from, vec_t to);
+vec_t randomNum(vec_t from, vec_t to);
 
 #endif
 

src/OpenRaider.cpp

  */
 
 #include <cstdio>
+#include <assert.h>
 
 #include "utils/strings.h"
 #include "OpenRaider.h"
 }
 
 int OpenRaider::loadConfig(const char *config) {
-    char *configFile = fullPath(config, 0);
+    assert(config != NULL);
 
+    char *configFile = fullPath(config, 0);
     printf("Trying to load \"%s\"...\n", configFile);
 
     return -1;

src/math/math.cpp

  * \brief Vector and Matrix math
  *
  * \author Mongoose
+ * \author xythobuz
  */
 
 #include <stdlib.h>
     return false;
 }
 
-
-inline vec_t square(vec_t a)
-{
-    return a * a;
-}
-
-
-int helIntersectionLineAndPolygon(vec3_t intersect,
-        vec3_t p1, vec3_t p2,
-        vec3_t *polygon)
-{
+int intersectionLinePolygon(vec3_t intersect,
+        vec3_t p1, vec3_t p2, vec3_t *polygon) {
     assert(polygon != NULL);
 
-    //  vec3_t normal, a, b;
+    // vec3_t normal, a, b;
     Vector3d a, b, normal, pA, pB;
     vec_t d, denominator, mu;
 
     normal.normalize();
 
     // find D
-    //d = (normal[0] * polygon[0][0] -
-    //    normal[1] * polygon[0][1] -
-    //    normal[2] * polygon[0][2]);
     d = (normal.mVec[0] * polygon[0][0] -
-            normal.mVec[1] * polygon[0][1] -
-            normal.mVec[2] * polygon[0][2]);
+         normal.mVec[1] * polygon[0][1] -
+         normal.mVec[2] * polygon[0][2]);
 
     // line segment parallel to plane?
     a = pB - pA;
 
-    //denominator = (normal[0] * a[0] +
-    //                  normal[1] * a[1] +
-    //                  normal[2] * a[2]);
     denominator = Vector3d::dot(normal, a);
 
     if (denominator > 0.0)
         return 0;
 
     // Line segment contains intercept point?
-    //mu = - ((d + normal[0] * p1[0] + normal[1] * p1[1] + normal[2] * p1[2]) /
-    //        denominator);
     mu = -((d + Vector3d::dot(normal, pA)) / denominator);
 
     if (mu < 0.0 || mu > 1.0)
         return 0;
 
-    //intersect[0] = p1[0] + mu * a[0];
-    //intersect[1] = p1[1] + mu * a[1];
-    //intersect[2] = p1[2] + mu * a[2];
     b = pA + (a * mu);
     intersect[0] = b.mVec[0];
     intersect[1] = b.mVec[1];
     intersect[2] = b.mVec[2];
 
-
     // 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
     return 1;
 }
 
-
-vec_t helDist3v(vec3_t a, vec3_t b)
-{
-    return (sqrtf( ((b[0] - a[0]) * (b[0] - a[0])) +
-                ((b[1] - a[1]) * (b[1] - a[1])) +
-                ((b[2] - a[2]) * (b[2] - a[2]))));
+vec_t distance(vec3_t a, vec3_t b) {
+    return sqrtf(((b[0] - a[0]) * (b[0] - a[0])) +
+                 ((b[1] - a[1]) * (b[1] - a[1])) +
+                 ((b[2] - a[2]) * (b[2] - a[2])));
 }
 
-
-void helMidpoint3v(vec3_t a, vec3_t b, vec3_t mid)
-{
+void midpoint(vec3_t a, vec3_t b, vec3_t mid) {
     mid[0] = (a[0] + b[0]) / 2.0f;
     mid[1] = (a[1] + b[1]) / 2.0f;
     mid[2] = (a[2] + b[2]) / 2.0f;
 }
 
-
-vec_t helNorm4v(vec4_t v)
-{
-    return (sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2] + v[3]*v[3]));
-}
-
-
-vec_t helNorm3v(vec3_t v)
-{
-    return (sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]));
-}
-
-
-vec_t helNorm2v(vec2_t v)
-{
-    return (sqrtf(v[0]*v[0] + v[1]*v[1]));
-}
-
-
-vec_t helRandomNum(vec_t from, vec_t to)
-{
+vec_t randomNum(vec_t from, vec_t to) {
     return from + ((to - from) * rand() / (RAND_MAX + 1.0f));
 }