SDL Breakout Engine: D:/Ryan_Temp/GithubProjects/monorepo-RyanRio/Assignment1_Breakout/Game/include/TinyMath.hpp Source File

Go to the documentation of this file.
 #ifndef TINYMATH_H
 #define TINYMATH_H
  
 #include <cmath>
 #include <iostream>
  
 // Forward references of each of the structs
 struct Vector3D;
 struct Matrix3D;
  
 struct Vector3D
 {
  
   float x, y, z;
   
   Vector3D() = default; 
  
   Vector3D(float a, float b, float c) : x(a), y(b), z(c) {}
  
   float &operator[](int i)
   {
     return ((&x)[i]);
   }
  
   const float &operator[](int i) const
   {
     return ((&x)[i]);
   }
  
   Vector3D &operator*=(float s)
   {
     x *= s;
     y *= s;
     z *= s;
     return (*this);
   }
  
   Vector3D &operator/=(float s)
   {
     x /= s;
     y /= s;
     z /= s;
     return (*this);
   }
  
   Vector3D &operator+=(const Vector3D &v)
   {
     x += v.x;
     y += v.y;
     z += v.z;
     return (*this);
   }
  
   Vector3D &operator-=(const Vector3D &v)
   {
     x -= v.x;
     y -= v.y;
     z -= v.z;
     return (*this);
   }
  
   bool operator==(const Vector3D &other);
  
   bool equals(const Vector3D &other, float tolerance);
 };
  
 static Vector3D abs(const Vector3D &other)
 {
   return Vector3D(fabs(other.x), fabs(other.y), fabs(other.z));
 }
  
 inline bool operator<(const Vector3D &a, float scalar)
 {
   return a.x < scalar && a.y < scalar && a.z < scalar;
 }
  
 inline float Dot(const Vector3D &a, const Vector3D &b)
 {
   return a.x * b.x + a.y * b.y + a.z * b.z;
 }
  
 inline Vector3D operator*(const Vector3D &v, float s)
 {
   return Vector3D(v.x * s, v.y * s, v.z * s);
 }
  
 inline Vector3D operator*(const Vector3D &v, const Vector3D &s)
 {
   return Vector3D(v.x * s.x, v.y * s.y, v.z * s.z);
 }
  
 inline Vector3D operator/(const Vector3D &v, float s)
 {
   return Vector3D(v.x / s, v.y / s, v.z / s);
 }
  
 inline Vector3D operator-(const Vector3D &v)
 {
   return Vector3D(v.x * -1, v.y * -1, v.z * -1);
 }
  
 inline float Magnitude(const Vector3D &v)
 {
   return sqrtf32(v.x * v.x + v.y * v.y + v.z * v.z);
 }
  
 inline Vector3D operator+(const Vector3D &a, const Vector3D &b)
 {
   return Vector3D(a.x + b.x, a.y + b.y, a.z + b.z);
 }
  
 inline Vector3D operator-(const Vector3D &a, const Vector3D &b)
 {
   return Vector3D(a.x - b.x, a.y - b.y, a.z - b.z);
 }
  
 inline Vector3D Project(const Vector3D &a, const Vector3D &b)
 {
   float mag = Magnitude(a);
   return (a / mag) * (Dot(a, b) / mag);
 }
  
 inline Vector3D Normalize(const Vector3D &v)
 {
   float mag = Magnitude(v);
   if (mag == 0) mag = 1;
   return v / mag;
 }
  
 inline Vector3D CrossProduct(const Vector3D &a, const Vector3D &b)
 {
   return Vector3D(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
 }
  
 inline bool Vector3D::operator==(const Vector3D &other)
 {
   return x == other.x && y == other.y && z == other.z;
 }
  
 // returns if two vectors are equal within a given tolerance, to account for floating point math
 inline bool Vector3D::equals(const Vector3D &other, float tolerance)
 {
   return abs(*this - other) < tolerance;
 }
  
 struct Matrix3D
 {
 private:
   float n[3][3]; 
  
 public:
   Matrix3D() = default; 
  
   Matrix3D(float n00, float n01, float n02,
            float n10, float n11, float n12,
            float n20, float n21, float n22)
   {
     n[0][0] = n00;
     n[0][1] = n01;
     n[0][2] = n02;
     n[1][0] = n10;
     n[1][1] = n11;
     n[1][2] = n12;
     n[2][0] = n20;
     n[2][1] = n21;
     n[2][2] = n22;
   }
  
   Matrix3D(const Vector3D &a, const Vector3D &b, const Vector3D &c)
   {
  
     n[0][0] = a.x;
     n[0][1] = a.y;
     n[0][2] = a.z;
     n[1][0] = b.x;
     n[1][1] = b.y;
     n[1][2] = b.z;
     n[2][0] = c.x;
     n[2][1] = c.y;
     n[2][2] = c.z;
   }
  
   float &operator()(int i, int j)
   {
     return (n[i][j]);
   }
  
   const float &operator()(int i, int j) const
   {
     return (n[i][j]);
   }
  
   Vector3D &operator[](int i)
   {
     return (*reinterpret_cast<Vector3D *>(n[i]));
   }
  
   const Vector3D &operator[](int i) const
   {
     return (*reinterpret_cast<const Vector3D *>(n[i]));
   }
  
   Vector3D column(int j)
   {
     return Vector3D(n[0][j], n[1][j], n[2][j]);
   }
  
   Vector3D column(int j) const
   {
     return Vector3D(n[0][j], n[1][j], n[2][j]);
   }
  
   bool operator==(const Matrix3D &other)
   {
     return (*this)[0] == other[0] && (*this)[1] == other[1] && (*this)[2] == other[2];
   }
  
   bool equals(const Matrix3D &other, float tolerance)
   {
     return (*this)[0].equals(other[0], tolerance) && (*this)[1].equals(other[2], tolerance) && (*this)[1].equals(other[2], tolerance);
   }
 };
  
 inline Matrix3D operator*(const Matrix3D &A, const Matrix3D &B)
 {
   const Vector3D col0 = B.column(0);
   const Vector3D col1 = B.column(1);
   const Vector3D col2 = B.column(2);
   return Matrix3D(Dot(A[0], col0), Dot(A[0], col1), Dot(A[0], col2),
                   Dot(A[1], col0), Dot(A[1], col1), Dot(A[1], col2),
                   Dot(A[2], col0), Dot(A[2], col1), Dot(A[2], col2));
 }
  
 inline Vector3D operator*(const Matrix3D &M, const Vector3D &v)
 {
   return Vector3D(Dot(M[0], v), Dot(M[1], v), Dot(M[2], v));
 }
  
 inline std::ostream &operator<<(std::ostream &os, const Vector3D &v)
 {
   os << "Vector: " << v.x << ", " << v.y << ", " << v.z;
   return os;
 }
  
 inline std::ostream &operator<<(std::ostream &os, const Matrix3D &m)
 {
   os << "Matrix: " << std::endl
      << m[0] << std::endl
      << m[1] << std::endl
      << m[2];
   return os;
 }
  
 #endif