Vector2D.hpp

[詳解]

//
//    二次元ベクトル 前方定義
//
//    Copyright (c) 2022-2024 udonrobo
//
 
#pragma once
 
#include <Udon/Algorithm/Math.hpp>
#include <Udon/Traits/EnumerableMacro.hpp>
 
namespace Udon
{
 
    struct Polar;
 
    struct Vec3;
 
 
    struct Vec2
    {
 
        using ValueType = double;
 
        ValueType x;
 
        ValueType y;
 
        static constexpr size_t Dimension = 2;
 
        constexpr Vec2() noexcept
            : x()
            , y()
        {
        }
 
        constexpr Vec2(ValueType x, ValueType y) noexcept
            : x(x)
            , y(y)
        {
        }
 
        Vec2(const Vec2&) = default;
 
        Vec2& operator=(const Vec2&) = default;
 
        friend constexpr Vec2 operator+(const Vec2& lhs, const Vec2& rhs) noexcept { return { lhs.x + rhs.x, lhs.y + rhs.y }; }
        friend constexpr Vec2 operator-(const Vec2& lhs, const Vec2& rhs) noexcept { return { lhs.x - rhs.x, lhs.y - rhs.y }; }
        friend constexpr Vec2 operator*(const Vec2& lhs, const Vec2& rhs) noexcept { return { lhs.x * rhs.x, lhs.y * rhs.y }; }
        friend constexpr Vec2 operator/(const Vec2& lhs, const Vec2& rhs) noexcept { return { lhs.x / rhs.x, lhs.y / rhs.y }; }
 
        friend constexpr Vec2 operator+(const Vec2& lhs, ValueType rhs) noexcept { return { lhs.x + rhs, lhs.y + rhs }; }
        friend constexpr Vec2 operator-(const Vec2& lhs, ValueType rhs) noexcept { return { lhs.x - rhs, lhs.y - rhs }; }
        friend constexpr Vec2 operator*(const Vec2& lhs, ValueType rhs) noexcept { return { lhs.x * rhs, lhs.y * rhs }; }
        friend constexpr Vec2 operator/(const Vec2& lhs, ValueType rhs) noexcept { return { lhs.x / rhs, lhs.y / rhs }; }
 
        friend constexpr Vec2 operator+(ValueType lhs, const Vec2& rhs) noexcept { return { lhs + rhs.x, lhs + rhs.x }; }
        friend constexpr Vec2 operator-(ValueType lhs, const Vec2& rhs) noexcept { return { lhs - rhs.x, lhs - rhs.x }; }
        friend constexpr Vec2 operator*(ValueType lhs, const Vec2& rhs) noexcept { return { lhs * rhs.x, lhs * rhs.x }; }
        friend constexpr Vec2 operator/(ValueType lhs, const Vec2& rhs) noexcept { return { lhs / rhs.x, lhs / rhs.x }; }
 
        Vec2& operator+=(const Vec2& rhs) noexcept { return *this = *this + rhs; };
        Vec2& operator-=(const Vec2& rhs) noexcept { return *this = *this - rhs; };
        Vec2& operator*=(const Vec2& rhs) noexcept { return *this = *this * rhs; };
        Vec2& operator/=(const Vec2& rhs) noexcept { return *this = *this / rhs; };
 
        Vec2& operator+=(ValueType rhs) noexcept { return *this = *this + rhs; };
        Vec2& operator-=(ValueType rhs) noexcept { return *this = *this - rhs; };
        Vec2& operator*=(ValueType rhs) noexcept { return *this = *this * rhs; };
        Vec2& operator/=(ValueType rhs) noexcept { return *this = *this / rhs; };
 
        friend constexpr bool operator==(const Vec2& lhs, const Vec2& rhs) noexcept { return lhs.x == rhs.x and lhs.y == rhs.y; };
        friend constexpr bool operator!=(const Vec2& lhs, const Vec2& rhs) noexcept { return not(lhs == rhs); };
 
        explicit constexpr operator bool() const noexcept
        {
            return x or y;
        }
 
        static constexpr Vec2 Zero() noexcept
        {
            return { 0, 0 };
        }
 
        constexpr bool isZero() const noexcept
        {
            return not operator bool();
        }
 
        void clear() noexcept
        {
            *this = Zero();
        }
 
        Vec2& replaceX(ValueType newValue) noexcept
        {
            x = newValue;
            return *this;
        }
 
        Vec2& replaceY(ValueType newValue) noexcept
        {
            y = newValue;
            return *this;
        }
 
        template <typename Visitor>
        Vec2& replaceX(Visitor&& visitor) noexcept
        {
            x = visitor(x);
            return *this;
        }
 
        template <typename Visitor>
        Vec2& replaceY(Visitor&& visitor) noexcept
        {
            y = visitor(y);
            return *this;
        }
 
        Vec2 abs() const noexcept
        {
            return {
                Udon::Abs(x),
                Udon::Abs(y)
            };
        }
 
        Vec2 rotatedAt(const Vec2& center, ValueType angle) const noexcept
        {
            const auto s = sin(-angle);
            const auto c = cos(-angle);
            const auto d = (*this - center);
            return center + Vec2{ (d.x * c - d.y * s), (d.x * s + d.y * c) };
        }
 
        Vec2& rotateAt(const Vec2& center, ValueType angle) noexcept
        {
            return *this = rotatedAt(center, angle);
        }
 
        Vec2 rotated(ValueType angle) const noexcept
        {
            return rotatedAt(Zero(), angle);
        }
 
        Vec2& rotate(ValueType angle) noexcept
        {
            return *this = rotated(angle);
        }
 
        ValueType angleAt(const Vec2& rhs) const noexcept
        {
            if (*this)
            {
                const auto d = *this - rhs;
                return atan2(d.x, d.y);
            }
            else
            {
                return 0.;
            }
        }
 
        ValueType angle() const noexcept
        {
            return angleAt(Zero());
        }
 
        ValueType distanceFrom(const Vec2& rhs) const noexcept
        {
            const auto d = *this - rhs;
            return sqrt(d.x * d.x + d.y * d.y);
        }
 
        ValueType length() const noexcept
        {
            return distanceFrom(Zero());
        }
 
        constexpr ValueType lengthSq() const noexcept
        {
            return x * x + y * y;
        }
 
        Vec2 scaledLength(ValueType length) const noexcept
        {
            return normalized() * length;
        }
 
        Vec2& scaleLength(ValueType length) noexcept
        {
            return *this = scaledLength(length);
        }
 
        constexpr Vec2 mapped(ValueType fromMin, ValueType fromMax, ValueType toMin, ValueType toMax) const noexcept
        {
            return {
                Map(x, fromMin, fromMax, toMin, toMax),
                Map(y, fromMin, fromMax, toMin, toMax),
            };
        }
 
        Vec2& map(ValueType fromMin, ValueType fromMax, ValueType toMin, ValueType toMax) noexcept
        {
            return *this = mapped(fromMin, fromMax, toMin, toMax);
        }
 
        Vec2 normalized() const noexcept
        {
            if (const auto len = length())
            {
                return *this / len;
            }
            else
            {
                return Zero();
            }
        }
 
        Vec2& normalize() noexcept
        {
            return *this = normalized();
        }
 
        constexpr Vec2 clamped(ValueType min, ValueType max) const noexcept
        {
            return { Udon::Constrain(x, min, max), Udon::Constrain(y, min, max) };
        }
 
        Vec2& clamp(ValueType min, ValueType max) noexcept
        {
            return *this = clamped(min, max);
        }
 
        Udon::Vec3 xy0() const noexcept;
 
        Udon::Polar toPolar() const noexcept;
 
#ifdef SIV3D_INCLUDED    
 
        template <typename T>
        constexpr Vec2(const s3d::Vector2D<T>& v) noexcept
            : x(static_cast<ValueType>(v.x))
            , y(static_cast<ValueType>(v.y))
        {
        }
 
        template <typename T>
        [[nodiscard]] s3d::Vector2D<T> asSivVec2() const noexcept
        {
            return {
                static_cast<T>(x),
                static_cast<T>(y),
            };
        }
 
        template <typename T>
        [[nodiscard]]
        operator s3d::Vector2D<T>() const noexcept
        {
            return asSivVec2<T>();
        }
#endif
 
#ifdef ARDUINO
        void show() const
        {
            Serial.print(F("x: ")), Serial.print(x), Serial.print('\t');
            Serial.print(F("y: ")), Serial.print(y), Serial.print('\t');
        }
#endif
 
        UDON_ENUMERABLE(x, y);
    };
 
}    // namespace Udon