Euler.hpp

[詳解]

//
//    オイラー角 前方定義
//
//    Copyright (c) 2022 udonrobo
//
 
 
#pragma once
 
#include <Udon/Algorithm/Math.hpp>    // Udon::Normalized
#include <Udon/Traits/EnumerableMacro.hpp>
#include <Udon/Serializer/Serializer.hpp>
 
namespace Udon
{
 
    struct Quaternion;
 

    struct EulerDirection
    {
        bool roll;
        bool pitch;
        bool yaw;
    };
 

    struct Euler
    {

        using ValueType = double;

        ValueType roll;

        ValueType pitch;

        ValueType yaw;

        constexpr Euler() noexcept
            : roll()
            , pitch()
            , yaw()
        {
        }

        constexpr Euler(ValueType roll, ValueType pitch, ValueType yaw) noexcept
            : roll(roll)
            , pitch(pitch)
            , yaw(yaw)
        {
        }

        Euler(const Euler&) = default;

        Euler& operator=(const Euler&) = default;
 
        constexpr Euler operator+(const Euler& rhs) const noexcept { return { roll + rhs.roll, pitch + rhs.pitch, yaw + rhs.yaw }; }
        constexpr Euler operator-(const Euler& rhs) const noexcept { return { roll - rhs.roll, pitch - rhs.pitch, yaw - rhs.yaw }; }
        constexpr Euler operator*(const Euler& rhs) const noexcept { return { roll * rhs.roll, pitch * rhs.pitch, yaw * rhs.yaw }; }
        constexpr Euler operator/(const Euler& rhs) const noexcept { return { roll / rhs.roll, pitch / rhs.pitch, yaw / rhs.yaw }; }
        constexpr Euler operator+(ValueType rhs) const noexcept { return { roll + rhs, pitch + rhs, yaw + rhs }; }
        constexpr Euler operator-(ValueType rhs) const noexcept { return { roll - rhs, pitch - rhs, yaw - rhs }; }
        constexpr Euler operator*(ValueType rhs) const noexcept { return { roll * rhs, pitch * rhs, yaw * rhs }; }
        constexpr Euler operator/(ValueType rhs) const noexcept { return { roll / rhs, pitch / rhs, yaw / rhs }; }
 
        Euler& operator+=(const Euler& rhs) noexcept { return *this = *this + rhs; };
        Euler& operator-=(const Euler& rhs) noexcept { return *this = *this - rhs; };
        Euler& operator*=(const Euler& rhs) noexcept { return *this = *this * rhs; };
        Euler& operator/=(const Euler& rhs) noexcept { return *this = *this / rhs; };
        Euler& operator+=(ValueType rhs) noexcept { return *this = *this + rhs; };
        Euler& operator-=(ValueType rhs) noexcept { return *this = *this - rhs; };
        Euler& operator*=(ValueType rhs) noexcept { return *this = *this * rhs; };
        Euler& operator/=(ValueType rhs) noexcept { return *this = *this / rhs; };
 
        constexpr bool operator==(const Euler& rhs) const noexcept
        {
            return roll == rhs.roll &&
                   pitch == rhs.pitch &&
                   yaw == rhs.yaw;
        };
        constexpr bool operator!=(const Euler& rhs) const noexcept
        {
            return !(*this == rhs);
        };

        explicit constexpr operator bool() const noexcept
        {
            return roll || pitch || yaw;
        }

        constexpr bool isZero() const noexcept
        {
            return !operator bool();
        }

        Euler normalized(ValueType min, ValueType max) const
        {
            return {
                Udon::Normalized(roll, min, max),
                Udon::Normalized(pitch, min, max),
                Udon::Normalized(yaw, min, max),
            };
        }

        constexpr Euler directionRevision(const EulerDirection& direction) const noexcept
        {
            return {
                roll * (direction.roll ? 1 : -1),
                pitch * (direction.pitch ? 1 : -1),
                yaw * (direction.yaw ? 1 : -1),
            };
        }

        Quaternion toQuaternion() const noexcept;

        void clear() noexcept
        {
            *this = {};
        }
 
#ifdef ARDUINO
        void show() const noexcept
        {
            Serial.print(F("r: ")), Serial.print(roll), Serial.print('\t');
            Serial.print(F("p: ")), Serial.print(pitch), Serial.print('\t');
            Serial.print(F("y: ")), Serial.print(yaw), Serial.print('\t');
        }
#endif
 
        UDON_ENUMERABLE(roll, pitch, yaw);
    };
 
}    // namespace Udon