math_vector3.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_VECTOR3_H_
#define DESIGNLAB_MATH_VECTOR3_H_
 
#include <cmath>
#include <string>
 
#include "math_util.h"
#include "math_vector2.h"
 
 
namespace designlab
{
 
struct Vector3 final
{
    constexpr Vector3() : x(0.f), y(0.f), z(0.f) {}
 
    constexpr Vector3(const float x_pos, const float y_pos, const float z_pos) :
        x(x_pos),
        y(y_pos),
        z(z_pos)
    {
    }
 
    constexpr Vector3(const Vector3& other) = default;
 
    constexpr Vector3(Vector3&& other) noexcept = default;
 
    constexpr Vector3& operator = (const Vector3& other) = default;
 
    ~Vector3() = default;
 
 
    constexpr bool operator == (const Vector3& v) const noexcept
    {
        if (math_util::IsEqual(v.x, x) && math_util::IsEqual(v.y, y) && math_util::IsEqual(v.z, z))
        {
            return true;
        }
 
        return false;
    }
 
    constexpr bool operator != (const Vector3& other) const noexcept
    {
        return !(*this == other);
    }
 
    bool operator < (const Vector3& other) const noexcept
    {
        // 長さで比較する．
        return GetLength() < other.GetLength();
    }
 
    bool operator > (const Vector3& other) const noexcept
    {
        return other < *this;
    }
 
    bool operator <= (const Vector3& other) const noexcept
    {
        return !(*this > other);
    }
 
    bool operator >= (const Vector3& other) const noexcept
    {
        return !(*this < other);
    }
 
    // 算術演算子，ベクトル同士の掛け算(内積・外積)はメンバ関数として実装する．
    constexpr Vector3 operator +() const noexcept { return *this; }
 
    constexpr Vector3 operator -() const noexcept { return { -x, -y, -z }; }
 
    constexpr Vector3 operator +(const Vector3& other) const noexcept
    {
        return { x + other.x , y + other.y, z + other.z };
    }
 
    constexpr Vector3 operator -(const Vector3& other) const noexcept
    {
        return { x - other.x , y - other.y, z - other.z };
    }
 
    constexpr Vector3 operator *(const float num) const noexcept
    {
        return { x * num, y * num, z * num };
    }
 
    constexpr Vector3 operator /(const float num) const
    {
        return { x / num, y / num, z / num };
    }
 
    Vector3& operator += (const Vector3& other) noexcept;
    Vector3& operator -= (const Vector3& other) noexcept;
    Vector3& operator *= (const float num) noexcept;
    Vector3& operator /= (const float num);
 
 
    [[nodiscard]] constexpr float GetSquaredLength() const noexcept
    {
        return x * x + y * y + z * z;
    }
 
    [[nodiscard]] inline float GetLength() const noexcept
    {
        return std::sqrt(GetSquaredLength());
    }
 
    [[nodiscard]] constexpr float Dot(const Vector3& other) const noexcept
    {
        return x * other.x + y * other.y + z * other.z;
    }
 
    [[nodiscard]] constexpr Vector3 Cross(const Vector3& other) const noexcept
    {
        return Vector3{ y * other.z - z * other.y, z * other.x - x * other.z, x * other.y - y * other.x };
    }
 
    [[nodiscard]] inline float GetDistanceFrom(const Vector3& other) const noexcept
    {
        return (*this - other).GetLength();
    }
 
    [[nodiscard]] Vector3 GetNormalized() const noexcept;
 
    [[nodiscard]] constexpr bool IsZero() const noexcept
    {
        if (math_util::IsEqual(x, 0.0f) && math_util::IsEqual(y, 0.0f) && math_util::IsEqual(z, 0.0f))
        {
            return true;
        }
 
        return false;
    }
 
    void Normalize() noexcept { *this = GetNormalized(); }
 
    [[nodiscard]]
    constexpr Vector2 ProjectedXY() const noexcept { return { x, y }; }
 
    [[nodiscard]]
    constexpr static Vector3 GetFrontVec() noexcept { return { 1, 0, 0 }; }
 
    [[nodiscard]]
    constexpr static Vector3 GetLeftVec() noexcept { return { 0, 1, 0 }; }
 
    [[nodiscard]]
    constexpr static Vector3 GetUpVec() noexcept { return { 0, 0, 1 }; }
 
    [[nodiscard]]
    constexpr static Vector3 GetZeroVec() noexcept { return { 0, 0, 0 }; }
 
 
    [[nodiscard]] std::string ToString() const;
 
    [[nodiscard]] std::string ToCsvString() const;
 
 
    float x;  
    float y;  
    float z;  
};
 
 
constexpr Vector3 operator * (const float s, const Vector3& vec) noexcept
{
    return { s * vec.x, s * vec.y, s * vec.z };
}
 
 
template <class Char>
std::basic_ostream<Char>& operator <<(std::basic_ostream<Char>& os, const Vector3& v)
{
    return os << math_util::FloatingPointNumToString(v.x) << Char(',') <<
        math_util::FloatingPointNumToString(v.y) << Char(',') <<
        math_util::FloatingPointNumToString(v.z);
}
 
 
template <class Char>
inline std::basic_istream<Char>& operator >>(std::basic_istream<Char>& is, Vector3& v)
{
    Char unused = 0;
    return is >> v.x >> unused >> v.y >> unused >> v.z;
}
 
 
// 正規化直行座標系となっているか確認する，
// 条件を満たさないならばコンパイルが通らない．
static_assert(math_util::IsEqual(Vector3::GetFrontVec().Dot(Vector3::GetLeftVec()), 0.f), "The dot product of FrontVec and LeftVec is not zero.");
 
static_assert(math_util::IsEqual(Vector3::GetFrontVec().Dot(Vector3::GetUpVec()), 0.f), "The dot product of FrontVec and UpVec is not zero.");
 
static_assert(math_util::IsEqual(Vector3::GetLeftVec().Dot(Vector3::GetUpVec()), 0.f), "The dot product of LeftVec and UpVec is not zero.");
 
static_assert(math_util::IsEqual(Vector3::GetFrontVec().GetSquaredLength(), 1.f), "FrontVec is not normalized.");
 
static_assert(math_util::IsEqual(Vector3::GetLeftVec().GetSquaredLength(), 1.f), "LeftVec is not normalized.");
 
static_assert(math_util::IsEqual(Vector3::GetUpVec().GetSquaredLength(), 1.f), "UpVec is not normalized.");
 
// 0ベクトルが返ってくるか確認する．
static_assert(Vector3::GetZeroVec().x == 0.f, "It is not a 0 vector.");
static_assert(Vector3::GetZeroVec().y == 0.f, "It is not a 0 vector.");
static_assert(Vector3::GetZeroVec().z == 0.f, "It is not a 0 vector.");
 
}  // namespace designlab
 
 
#endif  // DESIGNLAB_MATH_VECTOR3_H_