GxMath.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#include <limits.h>
 
GX_CORE_NAMESPACE_BEGIN()
 
// 円周率
static constexpr f32 PI = 3.14159265358979323846f;
static constexpr f32 PI2 = 6.28318530717958647693f;
static constexpr f32 PI_2 = 1.57079632679489661923f;
static constexpr f64 PI_D = 3.14159265358979323846;
static constexpr f64 PI2_D = 6.28318530717958647693;
static constexpr f64 PI_2_D = 1.57079632679489661923;
 
// 角度変換
#define DEGREE_TO_RADIAN(degree) ((degree) * static_cast<f32>(PI / 180.0f))
#define RADIAN_TO_DEGREE(radian) ((radian) * static_cast<f32>(180.0f / PI))
 
// ビット⇔バイト変換
#define BIT_TO_BYTE(__BIT__)    ((__BIT__) >> 3)
#define BYTE_TO_BIT(__BYTE__)   ((__BYTE__) << 3)
 
// 1メートル当たりの大きさ
static constexpr f32 WORLD_METER = 1.0f;
 
enum class AXIS
{
    X,      
    Y,      
    Z,      
    MAX,    
};
#if GX_DEVELOP
GX_ENUM_BEGIN(AXIS)
    GX_ENUM_VALUE("X軸", AXIS::X),
    GX_ENUM_VALUE("Y軸", AXIS::Y),
    GX_ENUM_VALUE("Z軸", AXIS::Z),
GX_ENUM_END()
#endif //GX_DEVELOP
 
enum class INIT
{
    NONE,       
    ZERO,       
    IDENTITY    
};
 
template<typename T,typename S>
static GX_FORCE_INLINE size_t AddAddress(T address, S value)
{
    return static_cast<size_t>(address) + static_cast<size_t>(value);
}
template<typename T,typename S>
static GX_FORCE_INLINE size_t SubAddress(T address, S value)
{
    return static_cast<size_t>(address) - static_cast<size_t>(value);
}
 
struct GxVector3;
 
//===========================================================================
//===========================================================================
class GxMath : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxMath, GxClassBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxMath)
 
    
    enum class PREFIX
    {
        NANO = -9,      
        MICRO = -6,     
        MILLI = -3,     
        ZERO = 0,       
        KILO = 3,       
        MEGA = 6,       
        GIGA = 9,       
    };
    static constexpr u32 NANO_INVERSE   = 1000000000;
    static constexpr u32 MICRO_INVERSE  = 1000000;
    static constexpr u32 MILLI_INVERSE  = 1000;
    static constexpr u32 KILO_VALUE     = 1000;
    static constexpr u32 MEGA_VALUE     = 1000000;
    static constexpr u32 GIGA_VALUE     = 1000000000;
 
    // 汎用数値定義
    static constexpr u32 VALUE_1    = 0x00000001;       
    static constexpr u32 VALUE_2    = 0x00000002;       
    static constexpr u32 VALUE_4    = 0x00000004;       
    static constexpr u32 VALUE_8    = 0x00000008;       
    static constexpr u32 VALUE_16   = 0x00000010;       
    static constexpr u32 VALUE_32   = 0x00000020;       
    static constexpr u32 VALUE_64   = 0x00000040;       
    static constexpr u32 VALUE_128  = 0x00000080;       
    static constexpr u32 VALUE_256  = 0x00000100;       
    static constexpr u32 VALUE_512  = 0x00000200;       
    static constexpr u32 VALUE_1K   = 0x00000400;       
    static constexpr u32 VALUE_2K   = 0x00000800;       
    static constexpr u32 VALUE_4K   = 0x00001000;       
    static constexpr u32 VALUE_8K   = 0x00002000;       
    static constexpr u32 VALUE_16K  = 0x00004000;       
    static constexpr u32 VALUE_32K  = 0x00008000;       
    static constexpr u32 VALUE_64K  = 0x00010000;       
    static constexpr u32 VALUE_128K = 0x00020000;       
    static constexpr u32 VALUE_256K = 0x00040000;       
    static constexpr u32 VALUE_512K = 0x00080000;       
    static constexpr u32 VALUE_1M   = 0x00100000;       
    static constexpr u32 VALUE_2M   = 0x00200000;       
    static constexpr u32 VALUE_4M   = 0x00400000;       
    static constexpr u32 VALUE_8M   = 0x00800000;       
    static constexpr u32 VALUE_16M  = 0x01000000;       
    static constexpr u32 VALUE_32M  = 0x02000000;       
    static constexpr u32 VALUE_64M  = 0x04000000;       
    static constexpr u32 VALUE_128M = 0x08000000;       
    static constexpr u32 VALUE_256M = 0x10000000;       
    static constexpr u32 VALUE_512M = 0x20000000;       
    static constexpr u32 VALUE_1G   = 0x40000000;       
    static constexpr u32 VALUE_2G   = 0x80000000;       
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxMath(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    template<class T> GX_FORCE_INLINE static T getAbs(const T value){ return ( value < 0 ) ? -value : value; }
    template<class T> GX_FORCE_INLINE static T getClamp(const T value, const T min, const T max){ return getMax(min, getMin(value, max)); }
    template<class T> GX_FORCE_INLINE static T getMin(const T value0, const T value1){ return value0 < value1 ? value0 : value1; }
    template<class T> GX_FORCE_INLINE static T getMax(const T value0, const T value1){ return value0 < value1 ? value1 : value0; }
    template<class T> GX_FORCE_INLINE static T getLerp(const T value0, const T value1, f32 ratio){ return static_cast<T>(ratio * value1 + (1.f - ratio) * value0); }
    template<class T> GX_FORCE_INLINE static void swap(T& a, T& b){ T c = a; a = b; b = c; }
    static f32 getLoop(f32 value, f32 min, f32 max);
    GX_FORCE_INLINE static f32 getLoopPI(f32 value){ return getLoop(value, -PI, PI); }
    GX_FORCE_INLINE static f32 getLoopPI2(f32 value){ return getLoop(value, 0, PI2); }
    static constexpr s32 getSign(s32 value){ return value < 0 ? -1 : (value > 0 ? 1 : 0); }
    static constexpr f32 getSign(f32 value){ return value < 0.f ? -1.f : (value > 0.f ? 1.f : 0.f); }
    static constexpr f32 getDegree(f32 radian) { return radian * (180.0f / PI); }
    static constexpr f64 getDegree(f64 radian) { return radian * (180.0 / PI_D); }
    static constexpr f32 getRadian(f32 degree) { return degree * (PI / 180.0f); }
    static constexpr f64 getRadian(f64 degree) { return degree * (PI_D / 180.0); }
    static f32 getMinRadian(f32 radian);
    GX_FORCE_INLINE static f32 getSaturate(const f32 value);
    GX_FORCE_INLINE static f64 getSaturate(const f64 value);
 
    GX_FORCE_INLINE static f32 getSin(const f32 radian){ return sinf(radian); }
    GX_FORCE_INLINE static f64 getSin(const f64 radian){ return sin(radian); }
    GX_FORCE_INLINE static f32 getFastSin(const f32 radian){ return sinf(radian); }
 
    GX_FORCE_INLINE static f32 getCos(const f32 radian){ return cosf(radian); }
    GX_FORCE_INLINE static f64 getCos(const f64 radian){ return cos(radian); }
    GX_FORCE_INLINE static f32 getFastCos(const f32 radian){ return cosf(radian); }
 
    GX_FORCE_INLINE static f32 getTan(const f32 radian){ return tanf(radian); }
    GX_FORCE_INLINE static f64 getTan(const f64 radian){ return tan(radian); }
    GX_FORCE_INLINE static f32 getFastTan(const f32 radian){ return tanf(radian); }
    
    GX_FORCE_INLINE static f32 getASin(const f32 value){ return asinf(value); }
    GX_FORCE_INLINE static f64 getASin(const f64 value){ return asin(value); }
    GX_FORCE_INLINE static f32 getFastASin(const f32 value){ return asinf(value); }
    
    GX_FORCE_INLINE static f32 getACos(const f32 value){ return acosf(value); }
    GX_FORCE_INLINE static f64 getACos(const f64 value){ return acos(value); }
    GX_FORCE_INLINE static f32 getFastACos(const f32 value){ return acosf(value); }
 
    GX_FORCE_INLINE static f32 getATan(const f32 value){ return atanf(value); }
    GX_FORCE_INLINE static f64 getATan(const f64 value){ return atan(value); }
    GX_FORCE_INLINE static f32 getFastATan(const f32 value){ return atanf(value); }
 
    GX_FORCE_INLINE static f32 getATan2(const f32 valueY, const f32 valueX){ return atan2f(valueY, valueX); }
    GX_FORCE_INLINE static f64 getATan2(const f64 valueY, const f64 valueX){ return atan2(valueY, valueX); }
    GX_FORCE_INLINE static f32 getFastATan2(const f32 valueY, const f32 valueX){ return atan2f(valueY, valueX); }
 
    GX_FORCE_INLINE static f32 getSqrtInverse(const f32 value){ return 1.0f / sqrtf(value); }
    GX_FORCE_INLINE static f64 getSqrtInverse(const f64 value){ return 1.0 / sqrt(value); }
 
    GX_FORCE_INLINE static f32 getSqrt(const f32 value){ return sqrtf(value); }
    GX_FORCE_INLINE static f64 getSqrt(const f64 value){ return sqrt(value); }
 
    GX_FORCE_INLINE static f32 getLog(const f32 value){ return logf(value); }
    GX_FORCE_INLINE static f64 getLog(const f64 value){ return log(value); }
    GX_FORCE_INLINE static f32 getLog(const f32 value, const f32 base){ return logf(value) / logf(base); }
    GX_FORCE_INLINE static f64 getLog(const f64 value, const f64 base){ return log(value) / log(base); }
 
    GX_FORCE_INLINE static f32 getPow(const f32 value, const f32 n){ return powf(value, n); }
    GX_FORCE_INLINE static f64 getPow(const f64 value, const f64 n){ return pow(value, n); }
 
    GX_FORCE_INLINE static f32 getExp(const f32 n){ return expf(n); }
    GX_FORCE_INLINE static f64 getExp(const f64 n){ return exp(n); }
    GX_FORCE_INLINE static f32 getFastExp(const f32 n){ return expf(n); }
 
    static u32 getLog(u32 value, const u32 base = 2);
    static u64 getPow(const u32 value, const u32 n);
    static u32 getFigure(const s64 value);
    static u32 getFigure(const u64 value);
    static u32 getHash32(void* pData, u32 size);
    static u32 getHash32(GX_CSTR string);
    static u32 getHash32(GX_CSTR string, u32 value);
    static u32 getHash32Encrypt(GX_CSTR string);
    static u32 getHash32(GX_CWSTR string);
    static u32 getHash32(GX_CWSTR string, u32 value);
    static u32 getHash32Encrypt(GX_CWSTR string);
    static u64 getHash64(void* pData, u32 size);
    static u64 getHash64Fast(void* pData, u32 size);
    static u64 getHash64(GX_CSTR string);
    static u64 getHash64(GX_CWSTR string);
    static u32 addHash32(u32 hash, u32 value);
    template<class T>GX_FORCE_INLINE static T getReverseEndian16(T value);
    template<class T>GX_FORCE_INLINE static T getReverseEndian32(T value);
    template<class T>GX_FORCE_INLINE static T getReverseEndian64(T value);
    template<class T>GX_FORCE_INLINE static T getReverseEndian128(T value);
    GX_FORCE_INLINE static u32 getBitCount(u32 value);
    template<class T> GX_FORCE_INLINE static b32 isPowerOfTwo(T value);
    template<class T> GX_FORCE_INLINE static b32 isAlignment(T value, u32 alignment);
    template<class T> GX_FORCE_INLINE static b32 isAlignmentFast(T value, u32 alignment);
    template<class T> GX_FORCE_INLINE static T getRoundUp(T value, u32 alignment);
    template<class T> GX_FORCE_INLINE static T getRoundDown(T value, u32 alignment);
    template<class T> GX_FORCE_INLINE static T getRoundUpFast(T value, size_t alignment);
    template<class T> GX_FORCE_INLINE static T getRoundDownFast(T value, u32 alignment);
    template<class T> GX_FORCE_INLINE static T getRoundUpPowerOfTwo(T value);
    GX_FORCE_INLINE static f32 getFloor( f32 value ){ return static_cast<f32>(floor(value)); }
    GX_FORCE_INLINE static f64 getFloor( f64 value ){ return floor(value); }
    GX_FORCE_INLINE static f32 getCeil( f32 value ){ return static_cast<f32>(ceil(value)); }
    GX_FORCE_INLINE static f64 getCeil( f64 value ){ return ceil(value); }
 
    static void calculateSplineTangent(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const f32 time, GxVector3& direct);
    static void calculateSplinePosition(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const f32 time, GxVector3& position);
    static void calculateBezierTangent(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const GxVector3& position3, const f32 time, GxVector3& direct);
    static void calculateBezierPosition(const GxVector3& position0, const GxVector3& position1, const GxVector3& position2, const GxVector3& position3, const f32 time, GxVector3& position);
 
    template<class T> static void geoCoordinatesToMeter(T longitude, T latitude, T centerLongitude, T centerLatitude, T& xMeter, T& zMeter);
 
    static u32 getRandom(u32 value);
 
};
 
//---------------------------------------------------------------------------
// 0.0f～1.0の範囲にクランプした値を取得(f32)
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxMath::getSaturate(const f32 value)
{
    return getClamp(value, 0.0f, 1.0f);
}
 
//---------------------------------------------------------------------------
// 0.0f～1.0の範囲にクランプした値を取得(f64)
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxMath::getSaturate(const f64 value)
{
    return getClamp(value, 0.0, 1.0);
}
 
//---------------------------------------------------------------------------
// エンディアン変換した値を取得(16bit版)
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getReverseEndian16(T value)
{
    return ((value & 0xff00) >> 8) | ((value & 0x00ff) << 8);
}
 
//---------------------------------------------------------------------------
// エンディアン変換した値を取得(32bit版)
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getReverseEndian32(T value)
{
    auto temporary = *reinterpret_cast<u32*>(&value);
    temporary = ((temporary & 0xff000000) >> 24) |
                ((temporary & 0x00ff0000) >> 8) |
                ((temporary & 0x0000ff00) << 8) |
                ((temporary & 0x000000ff) << 24);
    auto result = *reinterpret_cast<T*>(&temporary);
    return result;
}
 
//---------------------------------------------------------------------------
// エンディアン変換した値を取得(64bit版)
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getReverseEndian64(T value)
{
    auto temporary = *reinterpret_cast<u64*>(&value);
    temporary = ((temporary & 0xff00000000000000ULL) >> 56) |
                ((temporary & 0x00ff000000000000ULL) >> 40) |
                ((temporary & 0x0000ff0000000000ULL) >> 24) |
                ((temporary & 0x000000ff00000000ULL) >> 8) |
                ((temporary & 0x00000000ff000000ULL) << 8) |
                ((temporary & 0x0000000000ff0000ULL) << 24) |
                ((temporary & 0x000000000000ff00ULL) << 40) |
                ((temporary & 0x00000000000000ffULL) << 56);
    auto result = *reinterpret_cast<T*>(&temporary);
    return result;
}
 
//---------------------------------------------------------------------------
// エンディアン変換した値を取得(128bit版)
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getReverseEndian128(T value)
{
    u8 temporary[16];
    auto* pSrc = reinterpret_cast<u8*>(&value);
    for (u32 i = 0; i < 16; i++)
    {
        temporary[i] = pSrc[15 - i];
    }
    auto result = *reinterpret_cast<T*>(temporary);
    return result;
}
 
//---------------------------------------------------------------------------
// 1の立っているビット数取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE u32 GxMath::getBitCount(u32 value)
{
    value = ((value >> 1) & 0x55555555) + (value & 0x55555555);
    value = ((value >> 2) & 0x33333333) + (value & 0x33333333);
    value = ((value >> 4) & 0x0F0F0F0F) + (value & 0x0F0F0F0F);
    value = ((value >> 8) & 0x00FF00FF) + (value & 0x00FF00FF);
    value = ((value >>16) & 0x0000FFFF) + (value & 0x0000FFFF);
    return value;
}
 
//---------------------------------------------------------------------------
// 2のべき乗判定
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE b32 GxMath::isPowerOfTwo(T value)
{
    return !(static_cast<size_t>(value) & (static_cast<size_t>(value) - 1));
}
 
//---------------------------------------------------------------------------
// アライメント判定
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE b32 GxMath::isAlignment(T value, u32 alignment)
{
    return !((size_t)value % alignment);
}
 
//---------------------------------------------------------------------------
// アライメント判定(高速版 ※2のべき乗指定)
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE b32 GxMath::isAlignmentFast(T value, u32 alignment)
{
    GX_ASSERT(isPowerOfTwo(alignment), "argument error!! alignment(%d) is not power of two", alignment);
    return !((size_t)value & (alignment - 1));
}
 
//---------------------------------------------------------------------------
// 数値切り上げ
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getRoundUp(T value, u32 alignment)
{
    return ((size_t)value % alignment)? (T)(static_cast<size_t>(value) + alignment - (static_cast<size_t>(value) % alignment)) : value;
}
 
//---------------------------------------------------------------------------
// 数値切り捨て
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getRoundDown(T value, u32 alignment)
{
    return (value % alignment)? (T)(static_cast<size_t>(value) - (static_cast<size_t>(value) % alignment)) : value;
}
 
//---------------------------------------------------------------------------
// 数値切り上げ(高速版 ※2のべき乗指定)
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getRoundUpFast(T value, size_t alignment)
{
    GX_ASSERT(isPowerOfTwo(alignment), "argument error!! alignment(%d) is not power of two", alignment);
    return (T)(((size_t)value + (alignment - 1)) & ~(alignment - 1));
}
 
//---------------------------------------------------------------------------
// 数値切り捨て(高速版 ※2のべき乗指定)
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getRoundDownFast(T value, u32 alignment)
{
    GX_ASSERT(isPowerOfTwo(alignment), "argument error!! alignment(%d) is not power of two", alignment);
    return static_cast<T>(value & ~(static_cast<T>(alignment) - 1));
}
 
//---------------------------------------------------------------------------
// 2のべき乗に切り上げ
//---------------------------------------------------------------------------
template<class T>
GX_FORCE_INLINE T GxMath::getRoundUpPowerOfTwo(T value)
{
    T target = 2;
    while (target < value)
    {
        target = target << 1;
    }
    return target;
}
 
//---------------------------------------------------------------------------
// 緯度経度からメートルに変換
//---------------------------------------------------------------------------
template<class T>
void GxMath::geoCoordinatesToMeter(T longitude, T latitude, T centerLongitude, T centerLatitude, T& xMeter, T& zMeter)
{
    const T a = 6378137;
    const T F = 298.257222101;
    const T e2 = (2 * F - 1) / F / F;
 
    T nLatitude = GxMath::getRadian((longitude + centerLongitude) / 2.0);
    T dLatitude = GxMath::getRadian(longitude - centerLongitude);
    T dLongitude = GxMath::getRadian(latitude - centerLatitude);
 
    T sinValue = GxMath::getSin(nLatitude);
    T cosValue = GxMath::getCos(nLatitude);
 
    T w = GxMath::getSqrt(1 - e2 * sinValue * sinValue);
    T n = a / w;
    T m = a * (1 - e2) / (w * w * w);
 
    xMeter = dLongitude * n * cosValue;
    zMeter = -dLatitude * m;
}
 
// RTTIやプロパティなどの文字列からIDを作成するマクロ
#define HASH_CONST_VALUE 37
#define MAKE_ID_NAME_LENGTH_MAX UCHAR_MAX
 
GX_CORE_NAMESPACE_END()