mgl_vector2.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_VECTOR2_H_1606631290
#define INCGUARD_MGL_VECTOR2_H_1606631290
 
#include <algorithm>
#include <cmath>
 
#include <mgl/math/mgl_math_defs.h>
 
namespace MGL
{
struct Vector2
{
    float x;    
    float y;    
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Vector2() noexcept
        : x(0.0f)
        , y(0.0f)
    {}
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Vector2(float inX, float inY) noexcept
        : x(inX)
        , y(inY)
    {}
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Vector2 &operator+=(const Vector2 &rhs) noexcept
    {
        this->x += rhs.x;
        this->y += rhs.y;
 
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Vector2 &operator-=(const Vector2 &rhs) noexcept
    {
        this->x -= rhs.x;
        this->y -= rhs.y;
 
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Vector2 &operator*=(float rhs) noexcept
    {
        this->x *= rhs;
        this->y *= rhs;
 
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Vector2 &operator/=(float rhs) noexcept
    {
        this->x /= rhs;
        this->y /= rhs;
 
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] bool IsZero() const noexcept
    {
        return ((std::fabs(x) <= Math::kEpsilon) && (std::fabs(y) <= Math::kEpsilon));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] float Length() const noexcept
    {
        return std::sqrt((x * x) + (y * y));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] float Distance(const Vector2 &target) const noexcept
    {
        return Vector2(x - target.x, y - target.y).Length();
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] float Cross(const Vector2 &rhs) const noexcept
    {
        return (x * rhs.y) - (rhs.x * y);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] static float Cross(const Vector2 &lhs, const Vector2 &rhs) noexcept
    {
        return (lhs.x * rhs.y) - (rhs.x * lhs.y);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] float Dot(const Vector2 &rhs) const noexcept
    {
        return (x * rhs.x) + (y * rhs.y);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] static float Dot(const Vector2 &lhs, const Vector2 &rhs) noexcept
    {
        return (lhs.x * rhs.x) + (lhs.y * rhs.y);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] float GetAngle(const Vector2 &target) const noexcept
    {
        auto length = Length() * target.Length();
        if ((length == 0.0f) || (length == -0.0f))
        {
            return 0.0f;
        }
 
        auto dot = Dot(target);
        if ((dot == 0.0f) || (dot == -0.0f))
        {
            return Math::kHalfPi;
        }
 
        const float theta = std::clamp(dot / length, -1.0f, 1.0f);
        return std::acos(theta);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    bool Normalize() noexcept
    {
        if ((x == 0.0f) || (x == -0.0f))
        {
            if ((y == 0.0f) || (y == -0.0f))
            {
                return false;
            }
        }
 
        auto length = Length();
        x /= length;
        y /= length;
 
        return true;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    void Rotate(float radian) noexcept
    {
        auto srcX = x;
        x = srcX * std::cos(radian) - y * std::sin(radian);
        y = srcX * std::sin(radian) + y * std::cos(radian);
    }
};
 
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
constexpr Vector2 operator+(const Vector2 &lhs, const Vector2 &rhs) noexcept
{
    return {lhs.x + rhs.x, lhs.y + rhs.y};
}
 
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
constexpr Vector2 operator-(const Vector2 &lhs, const Vector2 &rhs) noexcept
{
    return {lhs.x - rhs.x, lhs.y - rhs.y};
}
 
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
constexpr Vector2 operator*(const Vector2 &lhs, float rhs) noexcept
{
    return {lhs.x * rhs, lhs.y * rhs};
}
 
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
constexpr Vector2 operator/(const Vector2 &lhs, float rhs) noexcept
{
    return {lhs.x / rhs, lhs.y / rhs};
}
}    // namespace MGL
 
#endif    // INCGUARD_MGL_VECTOR2_H_1606631290
 
// vim: et ts=4 sw=4 sts=4