Vector3D.hpp

[詳解]

//
//    三次元ベクトル 前方定義
//
//    Copyright (c) 2022-2024 udonrobo
//
 
#pragma once
 
#include <Udon/Algorithm/Math.hpp>
#include <Udon/Traits/EnumerableMacro.hpp>
 
namespace Udon
{
 
    struct Vec2;
 
 
    struct Vec3
    {
 
        using ValueType = double;
 
        ValueType x;
 
        ValueType y;
 
        ValueType z;
 
        static constexpr size_t Dimension = 3;
 
        constexpr Vec3() noexcept
            : x()
            , y()
            , z()
        {
        }
 
        constexpr Vec3(ValueType x, ValueType y, ValueType z) noexcept
            : x(x)
            , y(y)
            , z(z)
        {
        }
 
        Vec3(const Vec3&) = default;
 
        Vec3& operator=(const Vec3&) = default;
 
        friend constexpr Vec3 operator+(const Vec3& lhs, const Vec3& rhs) noexcept { return { lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z }; }
        friend constexpr Vec3 operator-(const Vec3& lhs, const Vec3& rhs) noexcept { return { lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z }; }
        friend constexpr Vec3 operator*(const Vec3& lhs, const Vec3& rhs) noexcept { return { lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z }; }
        friend constexpr Vec3 operator/(const Vec3& lhs, const Vec3& rhs) noexcept { return { lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z }; }
 
        friend constexpr Vec3 operator+(const Vec3& lhs, ValueType rhs) noexcept { return { lhs.x + rhs, lhs.y + rhs, lhs.z + rhs }; }
        friend constexpr Vec3 operator-(const Vec3& lhs, ValueType rhs) noexcept { return { lhs.x - rhs, lhs.y - rhs, lhs.z - rhs }; }
        friend constexpr Vec3 operator*(const Vec3& lhs, ValueType rhs) noexcept { return { lhs.x * rhs, lhs.y * rhs, lhs.z * rhs }; }
        friend constexpr Vec3 operator/(const Vec3& lhs, ValueType rhs) noexcept { return { lhs.x / rhs, lhs.y / rhs, lhs.z / rhs }; }
 
        friend constexpr Vec3 operator+(ValueType lhs, const Vec3& rhs) noexcept { return { lhs + rhs.x, lhs + rhs.y, lhs + rhs.z }; }
        friend constexpr Vec3 operator-(ValueType lhs, const Vec3& rhs) noexcept { return { lhs - rhs.x, lhs - rhs.y, lhs - rhs.z }; }
        friend constexpr Vec3 operator*(ValueType lhs, const Vec3& rhs) noexcept { return { lhs * rhs.x, lhs * rhs.y, lhs * rhs.z }; }
        friend constexpr Vec3 operator/(ValueType lhs, const Vec3& rhs) noexcept { return { lhs / rhs.x, lhs / rhs.y, lhs / rhs.z }; }
 
        Vec3& operator+=(const Vec3& rhs) noexcept { return *this = *this + rhs; };
        Vec3& operator-=(const Vec3& rhs) noexcept { return *this = *this - rhs; };
        Vec3& operator*=(const Vec3& rhs) noexcept { return *this = *this * rhs; };
        Vec3& operator/=(const Vec3& rhs) noexcept { return *this = *this / rhs; };
 
        Vec3& operator+=(ValueType rhs) noexcept { return *this = *this + rhs; };
        Vec3& operator-=(ValueType rhs) noexcept { return *this = *this - rhs; };
        Vec3& operator*=(ValueType rhs) noexcept { return *this = *this * rhs; };
        Vec3& operator/=(ValueType rhs) noexcept { return *this = *this / rhs; };
 
        friend constexpr bool operator==(const Vec3& lhs, const Vec3& rhs) noexcept { return lhs.x == rhs.x and lhs.y == rhs.y and lhs.z == rhs.z; }
        friend constexpr bool operator!=(const Vec3& lhs, const Vec3& rhs) noexcept { return not(lhs == rhs); }
 
        explicit constexpr operator bool() const noexcept
        {
            return x || y || z;
        }
 
        constexpr bool isZero() const noexcept
        {
            return not operator bool();
        }
 
        void clear() noexcept
        {
            *this = {};
        }
 
        Udon::Vec2 xy() const noexcept;
 
#ifdef SIV3D_INCLUDED    
 
        template <typename T>
        constexpr Vec3(const s3d::Vector3D<T>& v) noexcept
            : x(static_cast<double>(v.x))
            , y(static_cast<double>(v.y))
            , y(static_cast<double>(v.z))
        {
        }
 
        template <typename T>
        [[nodiscard]] s3d::Vector3D<T> asSivVec3() const noexcept
        {
            return {
                static_cast<T>(x),
                static_cast<T>(y),
                static_cast<T>(z),
            };
        }
 
        template <typename T>
        [[nodiscard]]
        operator s3d::Vector3D<T>() const noexcept
        {
            return asSivVec3<T>();
        }
#endif
 
#ifdef ARDUINO
        void show() const
        {
            Serial.print("x: "), Serial.print(x), Serial.print('\t');
            Serial.print("y: "), Serial.print(y), Serial.print('\t');
            Serial.print("z: "), Serial.print(z), Serial.print('\t');
        }
#endif
        UDON_ENUMERABLE(x, y, z);
    };
 
}    // namespace Udon