math_euler.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_MATH_EULER_H_
#define DESIGNLAB_MATH_EULER_H_
 
#include <string>
 
#include "math_util.h"
#include "math_vector3.h"
 
 
namespace designlab
{
 
struct EulerXYZ final
{
    constexpr EulerXYZ() : x_angle(0.f), y_angle(0.f), z_angle(0.f) {}
 
    constexpr EulerXYZ(const float x, const float y, const float z) :
        x_angle(x),
        y_angle(y),
        z_angle(z)
    {
    }
    constexpr EulerXYZ(const float x, const float y, const float z) : {…}
 
    constexpr EulerXYZ(const EulerXYZ& other) = default;
    constexpr EulerXYZ(EulerXYZ&& other) noexcept = default;
    constexpr EulerXYZ& operator =(const EulerXYZ& other) = default;
 
    ~EulerXYZ() = default;
 
    constexpr EulerXYZ operator *(const float s) const noexcept
    {
        return { x_angle * s, y_angle * s, z_angle * s };
    }
    constexpr EulerXYZ operator *(const float s) const noexcept {…}
 
 
    constexpr bool operator ==(const EulerXYZ& other) const noexcept
    {
        using math_util::IsEqual;
 
        return IsEqual(x_angle, other.x_angle) && IsEqual(y_angle, other.y_angle) && IsEqual(z_angle, other.z_angle);
    }
    constexpr bool operator ==(const EulerXYZ& other) const noexcept {…}
 
    constexpr bool operator !=(const EulerXYZ& other) const noexcept
    {
        return !(*this == other);
    }
    constexpr bool operator !=(const EulerXYZ& other) const noexcept {…}
 
 
    constexpr void SetDeg(const float x, const float y, const float z)
    {
        x_angle = math_util::ConvertDegToRad(x);
        y_angle = math_util::ConvertDegToRad(y);
        z_angle = math_util::ConvertDegToRad(z);
    }
    constexpr void SetDeg(const float x, const float y, const float z) {…}
 
    [[nodiscard]] std::string ToString() const;
 
    [[nodiscard]] std::string ToCsvString() const;
 
    [[nodiscard]] std::string ToStringDeg() const;
 
    [[nodiscard]] static constexpr EulerXYZ MakeEulerXYZDeg(const float x, const float y, const float z)
    {
        return EulerXYZ{ math_util::ConvertDegToRad(x), math_util::ConvertDegToRad(y), math_util::ConvertDegToRad(z) };
    }
    [[nodiscard]] static constexpr EulerXYZ MakeEulerXYZDeg(const float x, const float y, const float z) {…}
 
    float x_angle;  
    float y_angle;  
    float z_angle;  
};
 
 
template <class Char>
inline std::basic_ostream<Char>& operator <<(std::basic_ostream<Char>& os, const EulerXYZ& r)
{
    using math_util::FloatingPointNumToString;
 
    os << FloatingPointNumToString(r.x_angle) << Char(',') << FloatingPointNumToString(r.y_angle) << Char(',') << FloatingPointNumToString(r.z_angle);
 
    return os;
}
struct EulerXYZ final {…}
 
template <class Char>
inline std::basic_istream<Char>& operator >>(std::basic_istream<Char>& is, EulerXYZ& r)
{
    Char unused = 0;
    return is >> unused >> r.x_angle >> unused >> r.y_angle >> unused >> r.z_angle >> unused;
}
inline std::basic_istream<Char>& operator >>(std::basic_istream<Char>& is, EulerXYZ& r) {…}
 
 
[[nodiscard]] Vector3 RotateVector3(const Vector3& vec, const EulerXYZ& rot);
 
}  // namespace designlab
 
 
#endif  // DESIGNLAB_MATH_EULER_H_