KisaragiMath.hpp

[詳解]

#pragma once
 
/**
 * @file KisaragiMath.hpp
 * @brief 独自のMathを提供します
 * @author 樺澤陽向
 * @date 2025/05/09
 * @since
 
 
 
 Vector2型(削除済み)の関数を削除し、Vector2Dに対応させたものをPrimitiveMath.hppに移動
 */
 
#include <cassert>
 
namespace Kisaragi_Lib
{
    //double型 π.
    static const double PI = 3.1415926535897932384626433832795;
    //float型 π.
    static const float  PI_F = 3.1415926535897932384626433832795f;
 
    //double型 π * 2.
    static const double TWO_PI = 3.1415926535897932384626433832795 * 2.0;
    //float型 π * 2.
    static const float TWO_PI_F = 3.1415926535897932384626433832795f * 2.0f;
 
 
    static const double DEGREES_HALF = 180.0;
 
 
 
    /// <summary>
    /// 汎用計算クラス
    /// </summary>
    /// @since ver1.0.0 Vector2型(削除済み)の関数を削除し、Vector2Dに対応させたものをPrimitiveMath.hppに移動
    class Math
    {
    public:
 
        /// <summary>
        /// ラジアン値を角度に変換する.
        /// </summary>
        /// <param name="_radian">ラジアン値</param>
        /// <returns>角度</returns>
        static double RadianToDegree(const double& _radian)
        {
            return (_radian * DEGREES_HALF / PI);
        }
 
        /// <summary>
        /// 角度をラジアン値に変換する.
        /// </summary>
        /// <param name="_degree">角度</param>
        /// <returns>ラジアン値</returns>
        static double DegreeToRadian(const double& _degree)
        {
            return (_degree * PI / DEGREES_HALF);
        }
 
        /// <summary>
        /// 正規化された方向ベクトルから角度を求める.
        /// </summary>
        /// <param name="_vecX">正規化されたX方向のベクトル</param>
        /// <param name="_vecY">正規化されたY方向のベクトル</param>
        /// <returns>角度</returns>
        static double VectorToDegree(const double& _vecX, const double& _vecY)
        {
            return RadianToDegree(atan2(_vecY, _vecX));
        }
 
 
 
        /// <summary>
        /// 正規化された方向ベクトルからラジアン値を求める.
        /// </summary>
        /// <param name="_vecX">正規化されたX方向のベクトル</param>
        /// <param name="_vecY">正規化されたY方向のベクトル</param>
        /// <returns>ラジアン値</returns>
        static double VectorToRadian(const double& _vecX, const double& _vecY)
        {
            return atan2(_vecY, _vecX);
        }
 
 
 
        /// <summary>
        /// ベクトルを正規化する.
        /// </summary>
        /// <param name="_vecX">正規化したいベクトル</param>
        /// <param name="_vecY">正規化したいベクトル</param>
        template <class T>
        static void Normalize(T* _vecX, T* _vecY)
        {
            double vecLength = sqrt((*_vecX * *_vecX) + (*_vecY * *_vecY));
            //正規化されている(ベクトルの長さが1)なら.
            if (vecLength == 1)
            {
                //処理しない
                return;
            }
 
            //正規化処理.
            if (*_vecX != 0)
            {
                *_vecX = (*_vecX / vecLength);
            }
 
            if (*_vecY != 0)
            {
                *_vecY = (*_vecY / vecLength);
            }
 
        }
        
 
        /// <summary>
        /// べき乗,累乗
        /// </summary>
        /// <typeparam name="T">計算したい型</typeparam>
        /// <param name="_num">値</param>
        /// <param name="_cnt">回数</param>
        /// <returns>べき乗の結果</returns>
        template<class T>
        static T Pow(const T& _num ,const unsigned int& _cnt)
        {
            //0以下は想定してないっす.
            assert(_cnt > 0);
 
            T tmp = _num;
 
            //_cnt = 1の場合は代入だけして返すっす.
            for (int i = 1; i < _cnt; i++)
            {
                tmp *= _num;
            }
 
            return tmp;
        }
    };
}