Skip to content

Commit

Permalink
Overhaul vector types to use constexpr, simplify code
Browse files Browse the repository at this point in the history 
Fix uninitialized variable warnings in Vector2D
Resolves #92
#91
  • Loading branch information
@SamVanheer
SamVanheer committed Nov 28, 2021
1 parent 7258d55 commit e27bc78
Showing 1 changed file with 61 additions and 52 deletions.
113 changes: 61 additions & 52 deletions dlls/vector.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,23 +22,24 @@
class Vector2D
{
public:
inline Vector2D() {}
inline Vector2D(float X, float Y)
constexpr Vector2D() = default;
constexpr Vector2D(const Vector2D&) = default;
constexpr Vector2D& operator=(const Vector2D&) = default;

constexpr Vector2D(float X, float Y)
: x(X) , y(Y)
{
x = X;
y = Y;
}
inline Vector2D operator+(const Vector2D& v) const { return Vector2D(x + v.x, y + v.y); }
inline Vector2D operator-(const Vector2D& v) const { return Vector2D(x - v.x, y - v.y); }
inline Vector2D operator*(float fl) const { return Vector2D(x * fl, y * fl); }
inline Vector2D operator/(float fl) const { return Vector2D(x / fl, y / fl); }

inline float Length() const { return static_cast<float>(sqrt(x * x + y * y)); }
[[nodiscard]] constexpr Vector2D operator+(const Vector2D& v) const { return Vector2D(x + v.x, y + v.y); }
[[nodiscard]] constexpr Vector2D operator-(const Vector2D& v) const { return Vector2D(x - v.x, y - v.y); }
[[nodiscard]] constexpr Vector2D operator*(float fl) const { return Vector2D(x * fl, y * fl); }
[[nodiscard]] constexpr Vector2D operator/(float fl) const { return Vector2D(x / fl, y / fl); }

inline Vector2D Normalize() const
{
Vector2D vec2;
[[nodiscard]] float Length() const { return static_cast<float>(sqrt(x * x + y * y)); }

[[nodiscard]] Vector2D Normalize() const
{
float flLen = Length();
if (flLen == 0)
{
Expand All @@ -51,11 +52,18 @@ class Vector2D
}
}

vec_t x, y;
vec_t x = 0, y = 0;
};

inline float DotProduct(const Vector2D& a, const Vector2D& b) { return (a.x * b.x + a.y * b.y); }
inline Vector2D operator*(float fl, const Vector2D& v) { return v * fl; }
[[nodiscard]] constexpr float DotProduct(const Vector2D& a, const Vector2D& b)
{
return (a.x * b.x + a.y * b.y);
}

[[nodiscard]] constexpr Vector2D operator*(float fl, const Vector2D& v)
{
return v * fl;
}

//=========================================================
// 3D Vector
Expand All @@ -64,43 +72,36 @@ class Vector // same data-layout as engine's vec3_t,
{ // which is a vec_t[3]
public:
// Construction/destruction
inline constexpr Vector()
: x{}, y{}, z{}
{
}
constexpr Vector() = default;
constexpr Vector(const Vector&) = default;
constexpr Vector& operator=(const Vector&) = default;

inline constexpr Vector(float X, float Y, float Z)
constexpr Vector(float X, float Y, float Z)
: x(X), y(Y), z(Z)
{
}

//inline Vector(double X, double Y, double Z) { x = (float)X; y = (float)Y; z = (float)Z; }
//inline Vector(int X, int Y, int Z) { x = (float)X; y = (float)Y; z = (float)Z; }
inline constexpr Vector(const Vector& v)
: x(v.x), y(v.y), z(v.z)
{
}

inline constexpr Vector(float rgfl[3])
constexpr Vector(float rgfl[3])
: x(rgfl[0]), y(rgfl[1]), z(rgfl[2])
{
}

// Operators
inline Vector operator-() const { return Vector(-x, -y, -z); }
inline bool operator==(const Vector& v) const { return x == v.x && y == v.y && z == v.z; }
inline bool operator!=(const Vector& v) const { return !(*this == v); }
inline Vector operator+(const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); }
inline Vector operator-(const Vector& v) const { return Vector(x - v.x, y - v.y, z - v.z); }
inline Vector operator*(float fl) const { return Vector(x * fl, y * fl, z * fl); }
inline Vector operator/(float fl) const { return Vector(x / fl, y / fl, z / fl); }
[[nodiscard]] constexpr Vector operator-() const { return Vector(-x, -y, -z); }
[[nodiscard]] constexpr bool operator==(const Vector& v) const { return x == v.x && y == v.y && z == v.z; }
[[nodiscard]] constexpr bool operator!=(const Vector& v) const { return !(*this == v); }
[[nodiscard]] constexpr Vector operator+(const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); }
[[nodiscard]] constexpr Vector operator-(const Vector& v) const { return Vector(x - v.x, y - v.y, z - v.z); }
[[nodiscard]] constexpr Vector operator*(float fl) const { return Vector(x * fl, y * fl, z * fl); }
[[nodiscard]] constexpr Vector operator/(float fl) const { return Vector(x / fl, y / fl, z / fl); }

// Methods
inline void CopyToArray(float* rgfl) const { rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
inline float Length() const { return static_cast<float>(sqrt(x * x + y * y + z * z)); }
operator float*() { return &x; } // Vectors will now automatically convert to float * when needed
operator const float*() const { return &x; } // Vectors will now automatically convert to float * when needed
inline Vector Normalize() const
constexpr void CopyToArray(float* rgfl) const { rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
[[nodiscard]] float Length() const { return static_cast<float>(sqrt(x * x + y * y + z * z)); }
[[nodiscard]] constexpr operator float*() { return &x; } // Vectors will now automatically convert to float * when needed
[[nodiscard]] constexpr operator const float*() const { return &x; } // Vectors will now automatically convert to float * when needed

[[nodiscard]] Vector Normalize() const
{
float flLen = Length();
if (flLen == 0)
Expand All @@ -109,20 +110,28 @@ class Vector // same data-layout as engine's vec3_t,
return Vector(x * flLen, y * flLen, z * flLen);
}

inline Vector2D Make2D() const
[[nodiscard]] constexpr Vector2D Make2D() const
{
Vector2D Vec2;

Vec2.x = x;
Vec2.y = y;

return Vec2;
return {x, y};
}
inline float Length2D() const { return static_cast<float>(sqrt(x * x + y * y)); }

[[nodiscard]] float Length2D() const { return static_cast<float>(sqrt(x * x + y * y)); }

// Members
vec_t x, y, z;
vec_t x = 0, y = 0, z = 0;
};
inline Vector operator*(float fl, const Vector& v) { return v * fl; }
inline float DotProduct(const Vector& a, const Vector& b) { return (a.x * b.x + a.y * b.y + a.z * b.z); }
inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x); }

[[nodiscard]] constexpr Vector operator*(float fl, const Vector& v)
{
return v * fl;
}

[[nodiscard]] constexpr float DotProduct(const Vector& a, const Vector& b)
{
return (a.x * b.x + a.y * b.y + a.z * b.z);
}

[[nodiscard]] constexpr Vector CrossProduct(const Vector& a, const Vector& b)
{
return Vector(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
}

0 comments on commit e27bc78

Please sign in to comment.