d2Math.h

Go to the documentation of this file.

#ifndef D2MATH_H
#define D2MATH_H
 
#include <cmath>
#include <cfloat>
 
#include "d2api.h"
#include "d2Types.h"
 
#define d2Sqrt(x) sqrtf(x)
#define d2Atan2(y, x) atan2f(y, x)
#define d2Abs(x) ((x) > 0.0F ? (x) : -(x))
 
#define PI 3.14159265359f
#define TAU 6.28318530718f
 
struct D2_API d2Vec2
{
    d2Vec2() : x(0.0F), y(0.0F) {}
 
    d2Vec2(real x, real y) : x(x), y(y) {}
 
    ~d2Vec2() = default;
 
    void Zero() { x = 0.0F; y = 0.0F; }
 
    real Lenght() const { return d2Sqrt(x * x + y * y); }
 
    real LenghtSquared() const { return x * x + y * y; }
 
    d2Vec2 &Normalize();
 
    d2Vec2 UnitVector() const
    {
        d2Vec2 result = d2Vec2(0, 0);
        real length = Lenght();
        if (length != 0.0F) {
            result.x = x / length;
            result.y = y / length;
        }
        return result;
    }
 
    d2Vec2 Normal() const { return d2Vec2(y, -x).Normalize(); }
 
    real Dot(const d2Vec2 &v) const { return x * v.x + y * v.y; }
 
    real Cross(const d2Vec2 &v) const { return x * v.y - y * v.x; }
 
    // Overloaded operators
    d2Vec2 &operator=(const d2Vec2 &v);
    bool operator==(const d2Vec2 &v) const;
    bool operator!=(const d2Vec2 &v) const;
    d2Vec2 operator+(const d2Vec2 &v) const;
    d2Vec2 operator-(const d2Vec2 &v) const;
    d2Vec2 operator*(const real n) const;
    d2Vec2 operator*(const d2Vec2 &v) const;
    d2Vec2 operator/(const real n) const;
    d2Vec2 operator-();
    d2Vec2 &operator+=(const d2Vec2 &v);
    d2Vec2 &operator-=(const d2Vec2 &v);
    d2Vec2 &operator*=(const d2Vec2 &v);
    d2Vec2 &operator*=(const real n);
    d2Vec2 &operator/=(const real n);
 
    real x, y; // x and y components of the vector
};
 
struct D2_API d2VecN
{
    d2VecN();
 
    d2VecN(int N);
 
    d2VecN(const d2VecN &v);
 
    ~d2VecN();
 
    void Zero();
 
    real Dot(const d2VecN &v) const;
 
    // Overloaded operators
    d2VecN &operator=(const d2VecN &v);
    d2VecN operator+(const d2VecN &v) const;
    d2VecN operator-(const d2VecN &v) const;
    d2VecN operator*(const real n) const;
    const d2VecN &operator+=(const d2VecN &v);
    const d2VecN &operator-=(const d2VecN &v);
    const d2VecN &operator*=(const real n);
    real operator[](const int index) const;
    real &operator[](const int index);
 
    int N; 
    real *data; 
};
 
struct D2_API d2MatMN
{
    d2MatMN();
 
    d2MatMN(int M, int N);
 
    d2MatMN(const d2MatMN &m);
 
    ~d2MatMN();
 
    void Zero();
 
    d2MatMN Transpose() const;
 
    // Overloaded operators
    const d2MatMN &operator=(const d2MatMN &m);  // Assignment operator
    d2VecN operator*(const d2VecN &v) const;     // Matrix-vector multiplication
    d2MatMN operator*(const d2MatMN &m) const;   // Matrix-matrix multiplication
 
    static d2VecN SolveGaussSeidel(const d2MatMN &A, const d2VecN &b);
 
    int M; 
    int N; 
    d2VecN *rows; 
};
 
struct D2_API d2Rot
{
    real s;
 
    real c;
 
    d2Rot() : s(0.0F), c(0.0F) {}
 
    explicit d2Rot(real angle) : s(sinf(angle)), c(cosf(angle)) {}
 
    d2Rot(real s, real c) : s(s), c(c) {}
 
    void Set(real angle)
    {
        s = sinf(angle);
        c = cosf(angle);
    }
 
    void SetIdentity()
    {
        s = 0.0F;
        c = 1.0F;
    }
 
    inline real GetAngle() const { return d2Atan2(s, c); }
 
    inline d2Vec2 GetXAxis() const { return {c, s}; }
 
    inline d2Vec2 GetYAxis() const { return {-s, c}; }
 
    void Add(const d2Rot& other)
    {
        real temp_s = s * other.c + c * other.s;
        real temp_c = c * other.c - s * other.s;
        s = temp_s;
        c = temp_c;
    }
 
    d2Rot operator+(const d2Rot& other) const
    {
        d2Rot result = *this;
        result.Add(other);
        return result;
    }
 
    d2Rot& operator+=(const d2Rot& other)
    {
        this->Add(other);
        return *this;
    }
 
    d2Rot& operator+=(real angle)
    {
        real aSin = sinf(angle);
        real aCos = cosf(angle);
        real temp_s = s * aCos + c * aSin;
        real temp_c = c * aCos - s * aSin;
        s = temp_s; c = temp_c;
        return *this;
    }
};
 
struct D2_API d2Transform
{
    d2Vec2 p;
 
    d2Rot q;
 
    d2Transform() : p(0.0F, 0.0F), q() {}
 
    d2Transform(const d2Vec2& p, const d2Rot& q) : p(p), q(q) {}
 
    void SetIdentity()
    {
        p.Zero();
        q.SetIdentity();
    }
 
    void Set(const d2Vec2& p, const d2Rot& q)
    {
        this->p = p;
        this->q = q;
    }
};
 
 
template <typename T>
inline T
d2Min(T a, T b)
{
    return a < b ? a : b;
}
 
inline d2Vec2
d2Min(const d2Vec2& a, const d2Vec2& b)
{
    return {d2Min(a.x, b.x), d2Min(a.y, b.y)};
}
 
template <typename T>
inline T d2Max(T a, T b)
{
    return a > b ? a : b;
}
 
inline d2Vec2
d2Max(const d2Vec2& a, const d2Vec2& b)
{
    return {d2Max(a.x, b.x), d2Max(a.y, b.y)};
}
 
template <typename T>
inline T
d2Clamp(T value, T lower, T upper)
{
    return d2Max(lower, d2Min(value, upper));
}
 
// Operators
inline d2Vec2
operator * (real s, const d2Vec2& v)
{
    return {s * v.x, s * v.y};
}
 
// Rotate a d2Vec2
inline d2Vec2
d2Rotate(const d2Rot& rot, const d2Vec2& v)
{
    real x = rot.c * v.x - rot.s * v.y;
    real y = rot.s * v.x + rot.c * v.y;
    return {x, y};
}
 
#endif //D2MATH_H