Primitive.hpp

[詳解]

#pragma once
 
/**
 * @file Primitive.hpp
 * @brief 図形の形状を表すためのクラスを提供するヘッダ
 * @author 樺澤陽向
 * @date 2025/05/08
 * @since ver1.0.0 Bool型削除による変更
 */
 
#include "vector"
#include <cmath>
#include "../utility/Math/KisaragiMath.hpp"
 
using std::vector;
 
namespace Kisaragi_Lib
{
    //この変数以下の誤差は無視して、等しいとみなす.
    const static double EPSILON = 0.000001;
 
    /// <summary>
    /// 点を表すプリミティブ型
    /// </summary>
    /// <typeparam name="T">座標の型</typeparam>
    /// @since ver1.0.0 コメント追加
    template<typename T>
    struct Point2D
    {
        T x, y;
 
        Point2D() :x(0), y(0) {}
        Point2D(T _x, T _y) :x(_x), y(_y) {}
 
#pragma region 算術演算子 %抜き
        Point2D operator + (const Point2D _num) const
        {
            return Point2D(x + _num.x, y + _num.y);
        }
 
        Point2D operator - (const Point2D _num) const
        {
            return Point2D(x - _num.x, y - _num.y);
        }
 
        Point2D operator * (const Point2D _num) const
        {
            return Point2D(x * _num.x, y * _num.y);
        }
 
        Point2D operator / (const Point2D _num) const
        {
            return Point2D(x / _num.x, y / _num.y);
        }
#pragma endregion
 
#pragma region 算術代入子 %抜き
        const Point2D operator += (const Point2D _num)
        {
            x += _num.x;
            y += _num.y;
        
            return *this;
        }
 
        const Point2D operator -= (const Point2D _num)
        {
            x -= _num.x;
            y -= _num.y;
 
            return *this;
        }
 
        const Point2D operator *= (const Point2D _num)
        {
            x *= _num.x;
            y *= _num.y;
        
            return *this;
        }
 
        const Point2D operator /= (const Point2D _num)
        {
            x /= _num.x;
            y /= _num.y;
        
            return *this;
        }
#pragma endregion
 
#pragma region スカラー
        Point2D operator * (T _num) const
        {
            return Point2D(x * _num, y * _num);
        }
 
        Point2D operator / (T _num) const
        {
            return Point2D(x / _num, y / _num);
        }
 
        const Point2D operator *= (T _num)
        {
            x *= _num;
            y *= _num;
            
            return *this;
        }
 
        const Point2D operator /= (T _num)
        {
            x /= _num;
            y /= _num;
 
            return *this;
        }
#pragma endregion
 
        //符号反転演算子
        Point2D operator -() const
        {
            return Point2D(-x, -y);
        }
 
        //内積/ドット積
        T Dot(const Point2D _num) const
        {
            return x * _num.x + y * _num.y;
        }
 
        // クロス積/外積亜種?
        T Cross(const Point2D _num) const 
        {
            return x * _num.y - y * _num.x;
        }
 
        //ベクトルの長さを求める
        T Length() const
        {
            return std::sqrt(Math::Pow(x,2) + Math::Pow(y,2));
 
        }
 
        /// <summary>
        /// ベクトルを正規化する.
        /// </summary>
        /// <typeparam name="type">ベクトルの型</typeparam>
        /// <param name="_vec">正規化したいベクトル</param>
        /// <returns>正規化したベクトル</returns>
        Point2D<T> Normalize()
        {
            T vecLength = sqrt((x * x) + (y * y));
 
            //正規化されている(ベクトルの長さが1)なら.
            if (EpsilonIf(vecLength, 1, EPSILON)) 
            {
                //処理しない
                return *this;
            }
 
            //正規化処理.
            if (x != 0)
            {
                x = (x / vecLength);
            }
 
            if (y != 0)
            {
                y = (y / vecLength);
            }
 
            return *this;
 
        }
 
        Point2D GetNormalize() const
        {
            Point2D tmp(x, y);
            tmp.Normalize();
 
            return tmp;
        }
 
    };
 
    /// <summary>
    /// サイズを表すプリミティブ型
    /// 実体はPoint2D<T>と変わりありません
    /// </summary>
    /// <typeparam name="T">サイズの型</typeparam>
    /// @since ver1.0.0 コメント追加
    template<typename T>
    using Scale2D = Point2D<T>;
 
 
    /// <summary>
    /// ベクトルを表すプリミティブ型
    /// </summary>
    /// <typeparam name="T">ベクトルの型</typeparam>
    /// @since ver1.0.0 コメント追加
    template<typename T>
    struct Vector2D : public Point2D<T>
    {
        using Point2D<T>::x;
        using Point2D<T>::y;
 
        using Point2D<T>::Cross;
        using Point2D<T>::Dot;
        using Point2D<T>::GetNormalize;
 
 
        Vector2D() : Point2D<T>(){}
        Vector2D(T _x, T _y) : Point2D<T>(_x, _y) {}
 
        Vector2D operator = (Point2D<T> _p)
        {
            x = _p.x;
            y = _p.y;
 
            return *this;
        }
 
        //Point2Dをcastできるように
        explicit Vector2D(const Point2D<T>& _p) : Point2D<T>(_p.x, _p.y) {}
 
        //大体垂直か調べる
        bool isVertical(const Vector2D _vec) const
        {
            T dot = Dot(_vec);
            return IsRange(dot, -EPSILON, EPSILON);
        }
 
        //大体平行か調べる
        bool isParallel(const Vector2D _vec) const
        {
            T cross = Cross(_vec);
            return IsRange(cross, -EPSILON, EPSILON);
        }
 
        // 鋭角関係にあるか
        bool isSharpAngle(const Vector2D _vec) const 
        {
            return (Dot(_vec) >= 0.0f);
        }
 
        /// <summary>
        /// ベクトルから法線ベクトルを求める
        /// </summary>
        /// <typeparam name="T">Vector2Dの型</typeparam>
        /// <param name="_clockwise">時計回りの法線ベクトルにするか</param>
        /// <returns>法線ベクトル</returns>
        static Vector2D<T> GetNormalVector(Vector2D<T> _vec, bool _clockwise = true)
        {
            Vector2D<T> vec;
 
            //時計回りの法線ベクトルが欲しいなら
            if (_clockwise)
            {
                vec = Vector2D<T>(-_vec.y, _vec.x);
            }
            else
            {
                vec = Vector2D<T>(_vec.y, -_vec.x);
            }
 
            vec.Normalize();
 
            return vec;
        }
 
 
        /// <summary>
        /// 2点から方向ベクトル(非正規)を得る
        /// </summary>
        /// <typeparam name="Type">座標の型</typeparam>
        /// <param name="_startPoint">始点</param>
        /// <param name="_endPoint">終点</param>
        /// <returns>始点か終点  への方向ベクトル(非正規)</returns>
        template<typename Type>
        static Vector2D<Type> PointToVector(const Point2D<Type> _startPoint, const Point2D<Type> _endPoint)
        {
            return Vector2D<Type>(_endPoint - _startPoint);
        }
 
        /// <summary>
        /// 正規化された方向ベクトルから角度を求める.
        /// </summary>
        /// <typeparam name="T">ベクトルの型</typeparam>
        /// <param name="_vec">正規化された方向ベクトル</param>
        /// <returns>角度</returns>
        static double ToDegree(Vector2D<T> _vec)
        {
            //正規化
            _vec.Normalize();
 
            return Math::RadianToDegree(atan2(_vec.y, _vec.x));
        }
 
        /// <summary>
        /// 自身の角度を求める.
        /// </summary>
        /// <typeparam name="T">ベクトルの型</typeparam>
        /// <param name="_vec">正規化された方向ベクトル</param>
        /// <returns>角度</returns>
        double Degree()
        {
            //正規化
            Vector2D<T> _vec = *this;
            _vec = GetNormalize();
 
            return Math::RadianToDegree(atan2(_vec.y, _vec.x));
        }
 
        /// <summary>
        ///  方向ベクトルからラジアン値を求める.
        /// </summary>
        /// <typeparam name="T">ベクトルの型</typeparam>
        /// <param name="_vec">正規化された方向ベクトル</param>
        /// <returns>ラジアン値</returns>
        template<typename T>
        static double ToRadian(Vector2D<T> _vec)
        {
            //正規化
            _vec.Normalize();  
 
            return atan2(_vec.y, _vec.x);
        }
 
        /// <summary>
        ///  方向ベクトルからラジアン値を求める.
        /// </summary>
        /// <param name="_vec">正規化された方向ベクトル</param>
        /// <returns>ラジアン値</returns>
        double ToRadian()
        {
            Vector2D<T> _vec = *this;
            _vec.Normalize();
 
            return atan2(_vec.y, _vec.x);
        }
 
        /// <summary>
        /// ラジアンからベクトルを取得する.
        /// 0度がどこかは知らない.
        /// </summary>
        /// <typeparam name="type">ベクトルの型</typeparam>
        /// <param name="_radian">ラジアン値</param>
        /// <returns>取得したベクトル</returns>
        template<typename type>
        static Vector2D<type> RadianToVector(const type _radian)
        {
            Vector2D<type> tmp;
            tmp.x = cos(_radian);
            tmp.y = sin(_radian);
 
            return Vector2D<type>{ tmp.Normalize()};
        }
 
 
    };
 
    /// <summary>
    /// 始点と方向ベクトルで示される無限の直線を表すプリミティブ型
    /// </summary>
    /// <typeparam name="T">各値の数値型の種類</typeparam>
    /// @since ver1.0.0 コメント追加
    template<typename T>
    struct Line2D
    {
        Point2D<T> startPoint;  //始点
        Vector2D<T> direction;  //方向
 
        Line2D() : startPoint(0, 0), direction(0, 0) {}
 
        Line2D(Point2D<T> _startPoint,Vector2D<T> _direction) :
            startPoint(_startPoint), direction(_direction) 
        {
        }
 
        Point2D<T> GetPoint(T _length)
        {
            Point2D<T> tmp = direction;
 
            //方向ベクトルの長さを求める.
            tmp *= _length;
 
            //始点分ずらす.
            tmp += startPoint;
 
            return tmp;
        }
 
    };
 
    /// <summary>
    /// 始点と方向ベクトルで示される有限の直線を表すプリミティブ型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// @since ver1.0.0 コメント追加
    template<typename T>
    struct Segment2D : public Line2D<T>
    {
        using Line2D<T>::startPoint;
        using Line2D<T>::direction;
 
        Segment2D() : Line2D<T>() {}
 
        Segment2D(Point2D<T> _startPoint, Vector2D<T> _direction) :
            Line2D<T>(_startPoint, _direction){}
 
        Point2D<T> EndPoint() const
        {
            return Point2D<T>(startPoint + direction);
        }
 
    };
 
    /// <summary>
    /// 円を表すプリミティブ型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// @since ver1.0.0 コメント追加
    template<typename T>
    struct Circle2D
    {
        Point2D<T> center;
        T radius;
 
        Circle2D() : center(0, 0), radius(0) {}
 
        Circle2D(Point2D<T> _center,T _radius) : center(_center), radius(_radius) {}
    };
 
    /// <summary>
    /// 楕円形を表すプリミティブ型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// @since ver1.0.0 コメント追加
    template<typename T>
    struct Capsule2D
    {
        Segment2D<T> segment;
        T radius;
 
        Capsule2D() :segment(Point2D<T>(), Vector2D<T>()), radius(0) {}
 
        Capsule2D(Segment2D<T> _segment,T ) :segment(_segment), radius(0) {}
 
        Capsule2D(Point2D<T> _point, Vector2D<T> _vector,T _radius) :segment(), radius() {}
 
    };
 
    /// <summary>
    /// 軸平行境界ボックス
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// @since ver1.0.0 コメント追加
    template<typename T>
    struct AABB
    {
        //中心座標のずれ(ローカル)
        Point2D<T> offset;
 
        Scale2D<T> size;
 
        AABB(Point2D<T> _offset, Scale2D<T> _size) : offset(_offset), size(_size) {}
        AABB(Scale2D<T> _size) : offset(Point2D<T>(0,0)), size(_size) {}
 
 
        //TODO debug
        Point2D<T> LeftTopPoint()
        {
            //center - {(size / 2) - offset}    == 左上座標 (ずれ込み)
            // {}内の部分を計算で求めてる
            //左上座標 - ずれ
            return -(size / 2) - offset;
        }
 
        Point2D<T> RightBottomPoint()
        {
            return (size / 2) + offset;
        }
    };
}