Adding code

src/J3ML/LinearAlgebra/Vector2.cpp

@@ -0,0 +1,175 @@
+#include <J3ML/LinearAlgebra/Vector2.h>
+
+namespace LinearAlgebra {
+
+
+
+#pragma region vector2
+
+Vector2::Vector2(): x(0), y(0)
+{}
+
+Vector2::Vector2(float X, float Y): x(X), y(Y)
+{}
+
+Vector2::Vector2(const Vector2& rhs): x(rhs.x), y(rhs.y)
+{}
+
+float Vector2::operator[](std::size_t index)
+{
+    assert(index < 2);
+    if (index == 0) return x;
+    if (index == 1) return y;
+    return 0;
+}
+
+bool Vector2::IsWithinMarginOfError(const Vector2& rhs, float margin) const
+{
+    return this->Distance(rhs) <= margin;
+}
+
+bool Vector2::operator==(const Vector2& rhs) const
+{
+    return this->IsWithinMarginOfError(rhs);
+}
+
+bool Vector2::operator!=(const Vector2& rhs) const
+{
+    return this->IsWithinMarginOfError(rhs) == false;
+}
+
+Vector2 Vector2::Min(const Vector2& min) const
+{
+    return {
+            std::min(this->x, min.x),
+            std::min(this->y, min.y)
+    };
+}
+
+Vector2 Vector2::Max(const Vector2& max) const
+{
+    return {
+            std::max(this->x, max.x),
+            std::max(this->y, max.y)
+    };
+}
+
+Vector2 Vector2::Clamp(const Vector2& min, const Vector2& max) const
+{
+    return {
+            std::clamp(this->x, min.x, max.x),
+            std::clamp(this->y, min.y, max.y)
+    };
+}
+
+float Vector2::Distance(const Vector2& to) const
+{
+    return ((*this)-to).Magnitude();
+}
+
+float Vector2::Length() const
+{
+    return std::sqrt(LengthSquared());
+}
+
+float Vector2::LengthSquared() const
+{
+    return (x*x + y*y);
+}
+
+float Vector2::Magnitude() const
+{
+    return std::sqrt(LengthSquared());
+}
+
+float Vector2::Dot(const Vector2& rhs) const
+{
+    auto a = this->Normalize();
+    auto b = rhs.Normalize();
+
+    return a.x * b.x + a.y * b.y;
+}
+
+Vector2 Vector2::Project(const Vector2& rhs) const
+{
+    float scalar = this->Dot(rhs) / (rhs.Magnitude()*rhs.Magnitude());
+    return rhs * scalar;
+}
+
+Vector2 Vector2::Normalize() const
+{
+    if (Length() > 0)
+        return {
+                x / Length(),
+                y / Length()
+        };
+    else
+        return {0,0};
+}
+
+Vector2 Vector2::Lerp(const Vector2& rhs, float alpha) const
+{
+    return this->operator*(1.0f - alpha) + (rhs * alpha);
+}
+
+float Vector2::AngleBetween(const Vector2& rhs) const
+{
+    auto numer = this->Dot(rhs);
+    auto denom = this->Magnitude() * rhs.Magnitude();
+    return std::acos(numer / denom);
+}
+
+float Vector2::AngleBetween(const Vector2& lhs, const Vector2& rhs)
+{ return lhs.AngleBetween(rhs); }
+
+Vector2 Vector2::operator+(const Vector2& rhs) const
+{
+    return {this->x + rhs.x, this->y + rhs.y};
+}
+
+Vector2 Vector2::operator-(const Vector2& rhs) const
+{
+    return {this->x - rhs.x, this->y - rhs.y};
+}
+
+Vector2 Vector2::operator*(float rhs) const
+{
+    return {
+            this->x * rhs,
+            this->y * rhs
+    };
+}
+
+Vector2 Vector2::operator/(float rhs) const
+{
+    return {
+            this->x / rhs,
+            this->y / rhs
+    };
+}
+
+Vector2 Vector2::operator-() const
+{
+    return {-x, -y};
+}
+
+const Vector2 Vector2::Zero  = {0, 0};
+const Vector2 Vector2::Up    = {0, -1};
+const Vector2 Vector2::Down  = {0, 1};
+const Vector2 Vector2::Left  = {-1, 0};
+const Vector2 Vector2::Right = {1, 0};
+
+    float Vector2::GetX() const { return x; }
+
+    float Vector2::GetY() const { return y; }
+
+    float Vector2::LengthSquared(const Vector2 &of) { return of.LengthSquared(); }
+
+    Vector2 Vector2::Min(const Vector2 &value, const Vector2 &minimum) { return value.Min(minimum); }
+
+    Vector2 Vector2::Max(const Vector2 &value, const Vector2 &maximum) { return value.Max(maximum);}
+
+    float Vector2::Length(const Vector2 &of) { return of.Length(); }
+
+#pragma endregion
+}