GxVectord.inl

Go to the documentation of this file.

//===========================================================================
//===========================================================================
 
GX_CORE_NAMESPACE_BEGIN()
 
#define GX_VECTOR_ZERO_VECTOR_CHECK_VALUE   F32_ABS_MIN     // ゼロベクトルをチェックする定数
 
//===========================================================================
// GxVector2d
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d::GxVector2d(f64 x, f64 y)
: _x(x)
, _y(y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d::GxVector2d(const GxDouble2& double2)
: _x(double2._x)
, _y(double2._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d::GxVector2d(const f64* pDoubleArray)
: _x(pDoubleArray[0])
, _y(pDoubleArray[1])
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d::GxVector2d(const GxPoint2& point)
: _x(static_cast<f64>(point._x))
, _y(static_cast<f64>(point._y))
{
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d::GxVector2d(const GxVector2d& vector)
: _x(vector._x)
, _y(vector._y)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator = (const GxVector2d& vector)
{
    _x = vector._x;
    _y = vector._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator += (f64 scalar)
{
    addScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator -= (f64 scalar)
{
    subScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator *= (f64 scalar)
{
    mulScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator /= (f64 scalar)
{
    divScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator += (const GxVector2d& vector)
{
    addVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator -= (const GxVector2d& vector)
{
    subVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator *= (const GxVector2d& vector)
{
    mulVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d& GxVector2d::operator /= (const GxVector2d& vector)
{
    divVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator + (const GxVector2d& vector, f64 scalar)
{
    GxVector2d result;
    return GxVector2d::getAddScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator - (const GxVector2d& vector, f64 scalar)
{
    GxVector2d result;
    return GxVector2d::getSubScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator * (const GxVector2d& vector, f64 scalar)
{
    GxVector2d result;
    return GxVector2d::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator * (f64 scalar, const GxVector2d& vector)
{
    GxVector2d result;
    return GxVector2d::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator / (const GxVector2d& vector, f64 scalar)
{
    GxVector2d result;
    return GxVector2d::getDivScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator + (const GxVector2d& vector0, const GxVector2d& vector1)
{
    GxVector2d result;
    return GxVector2d::getAddVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator - (const GxVector2d& vector0, const GxVector2d& vector1)
{
    GxVector2d result;
    return GxVector2d::getSubVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator * (const GxVector2d& vector0, const GxVector2d& vector1)
{
    GxVector2d result;
    return GxVector2d::getMulVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d operator / (const GxVector2d& vector0, const GxVector2d& vector1)
{
    GxVector2d result;
    return GxVector2d::getDivVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxVector2d& vector0, const GxVector2d& vector1)
{
    return (vector0._x == vector1._x) && (vector0._y == vector1._y);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxVector2d& vector0, const GxVector2d& vector1)
{
    return (vector0._x != vector1._x) || (vector0._y != vector1._y);
}
 
//---------------------------------------------------------------------------
// const配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE const f64& GxVector2d::operator[](u32 i) const
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// 配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64& GxVector2d::operator[](u32 i)
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// ゼロベクトル判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector2d::isZeroVector(void) const
{
    return (getLengthSquare() <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE);
}
 
//---------------------------------------------------------------------------
// 長さを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector2d::getLength(void) const
{
    return GxMath::getSqrt(getLengthSquare());
}
 
//---------------------------------------------------------------------------
// 長さの2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector2d::getLengthSquare(void) const
{
    return _x * _x + _y * _y;
}
 
//---------------------------------------------------------------------------
// 長さを設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector2d::setLength(f64 length)
{
    auto oldLength = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < oldLength * oldLength, "ゼロベクトルに長さを設定しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (oldLength * oldLength <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        oldLength = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( oldLength * oldLength <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルに長さを設定しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        oldLength = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto scale = length / oldLength;
 
    _x *= scale;
    _y *= scale;
}
 
//---------------------------------------------------------------------------
// 長さを設定(長さ0に対応)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector2d::setLengthEx(f64 length)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto scale = length / GxMath::getSqrt(lengthSquare);
 
        _x *= scale;
        _y *= scale;
    }
    else
    {
        _x = 0.0;
        _y = 0.0;
    }
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d GxVector2d::getNormalize(void) const
{
    auto length = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length * length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        length = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
 
    return GxVector2d(_x * inverseLength, _y * inverseLength);
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d GxVector2d::getNormalizeEx(void) const
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
 
        return GxVector2d(_x * inverseLength, _y * inverseLength);
    }
    else
    {
        return GxVector2d::ZERO;
    }
}
 
//---------------------------------------------------------------------------
// スカラ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getAddScalar(GxVector2d& dst, const GxVector2d& vector, f64 scalar)
{
    dst._x = vector._x + scalar;
    dst._y = vector._y + scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getSubScalar(GxVector2d& dst, const GxVector2d& vector, f64 scalar)
{
    dst._x = vector._x - scalar;
    dst._y = vector._y - scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getMulScalar(GxVector2d& dst, const GxVector2d& vector, f64 scalar)
{
    dst._x = vector._x * scalar;
    dst._y = vector._y * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getDivScalar(GxVector2d& dst, const GxVector2d& vector, f64 scalar)
{
    auto inverseLength = 1.0 / scalar;
 
    dst._x = vector._x * inverseLength;
    dst._y = vector._y * inverseLength;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getAddVector(GxVector2d& dst, const GxVector2d& vector0, const GxVector2d& vector1)
{
    dst._x = vector0._x + vector1._x;
    dst._y = vector0._y + vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getSubVector(GxVector2d& dst, const GxVector2d& vector0, const GxVector2d& vector1)
{
    dst._x = vector0._x - vector1._x;
    dst._y = vector0._y - vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getMulVector(GxVector2d& dst, const GxVector2d& vector0, const GxVector2d& vector1)
{
    dst._x = vector0._x * vector1._x;
    dst._y = vector0._y * vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getDivVector(GxVector2d& dst, const GxVector2d& vector0, const GxVector2d& vector1)
{
    dst._x = vector0._x / vector1._x;
    dst._y = vector0._y / vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getNormalize(GxVector2d& dst, const GxVector2d& vector)
{
    auto length = vector.getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length* length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        length = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
 
    dst._x = vector._x * inverseLength;
    dst._y = vector._y * inverseLength;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getNormalizeEx(GxVector2d& dst, const GxVector2d& vector)
{
    const auto lengthSquare = vector.getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
 
        dst._x = vector._x * inverseLength;
        dst._y = vector._y * inverseLength;
    }
    else
    {
        dst._x = 0.0;
        dst._y = 0.0;
    }
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 内積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector2d::getDot(const GxVector2d& vector0, const GxVector2d& vector1)
{
    return vector0._x * vector1._x + vector0._y * vector1._y;
}
 
//---------------------------------------------------------------------------
// 外積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector2d::getCross(const GxVector2d& vector0, const GxVector2d& vector1)
{
    return vector0._x * vector1._y - vector0._y * vector1._x;
}
 
//---------------------------------------------------------------------------
// 角度差を取得(符号つき radian)
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector2d::getAngle(const GxVector2d& vector0, const GxVector2d& vector1)
{
    if( vector0.isZeroVector() || vector0.isZeroVector() )
    {
        return 0.0;
    }
 
    const auto cosTheta = GxVector2d::getDot(vector0, vector1);
    const auto sinTheta = GxVector2d::getCross(vector0, vector1);
 
    return GxMath::getATan2(sinTheta, cosTheta);
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d GxVector2d::getMinimum(const GxVector2d& vector0, const GxVector2d& vector1)
{
    return GxVector2d(vector0._x < vector1._x ? vector0._x : vector1._x,
                     vector0._y < vector1._y ? vector0._y : vector1._y);
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getMinimum(GxVector2d& dst, const GxVector2d& vector0, const GxVector2d& vector1)
{
    dst._x = vector0._x < vector1._x ? vector0._x : vector1._x;
    dst._y = vector0._y < vector1._y ? vector0._y : vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 要素毎に最大値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d GxVector2d::getMaximum(const GxVector2d& vector0, const GxVector2d& vector1)
{
    return GxVector2d(vector0._x > vector1._x ? vector0._x : vector1._x,
                     vector0._y > vector1._y ? vector0._y : vector1._y);
}
 
//---------------------------------------------------------------------------
// 要素毎に最大値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getMaximum(GxVector2d& dst, const GxVector2d& vector0, const GxVector2d& vector1)
{
    dst._x = vector0._x > vector1._x ? vector0._x : vector1._x;
    dst._y = vector0._y > vector1._y ? vector0._y : vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 線形補間
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2d GxVector2d::getLerp(const GxVector2d& vector0, const GxVector2d& vector1, f64 t)
{
    return GxVector2d(vector0._x + (vector1._x - vector0._x) * t,
                     vector0._y + (vector1._y - vector0._y) * t);
}
 
//---------------------------------------------------------------------------
// 線形補間
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::getLerp(GxVector2d& dst, const GxVector2d& vector0, const GxVector2d& vector1, f64 t)
{
    dst._x = vector0._x + (vector1._x - vector0._x) * t;
    dst._y = vector0._y + (vector1._y - vector0._y) * t;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::addScalar(f64 scalar)
{
    _x += scalar;
    _y += scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::subScalar(f64 scalar)
{
    _x -= scalar;
    _y -= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::mulScalar(f64 scalar)
{
    _x *= scalar;
    _y *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::divScalar(f64 scalar)
{
    auto inverseScalar = 1.0 / scalar;
 
    _x *= inverseScalar;
    _y *= inverseScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::addVector(const GxVector2d& vector)
{
    _x += vector._x;
    _y += vector._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::subVector(const GxVector2d& vector)
{
    _x -= vector._x;
    _y -= vector._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::mulVector(const GxVector2d& vector)
{
    _x *= vector._x;
    _y *= vector._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::divVector(const GxVector2d& vector)
{
    _x /= vector._x;
    _y /= vector._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::normalize(void)
{
    auto length = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length * length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        length = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
 
    _x *= inverseLength;
    _y *= inverseLength;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2d& GxVector2d::normalizeEx(void)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
 
        _x *= inverseLength;
        _y *= inverseLength;
    }
    else
    {
        _x = 0.0;
        _y = 0.0;
    }
 
    return *this;
}
 
//===========================================================================
// GxVector3d
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d::GxVector3d(f64 x, f64 y, f64 z)
: _x(x)
, _y(y)
, _z(z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d::GxVector3d(const GxDouble3& double3)
: _x(double3._x)
, _y(double3._y)
, _z(double3._z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d::GxVector3d(const f64* pDoubleArray)
: _x(pDoubleArray[0])
, _y(pDoubleArray[1])
, _z(pDoubleArray[2])
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d::GxVector3d(const GxPoint2& point, f64 z)
: _x(static_cast<f64>(point._x))
, _y(static_cast<f64>(point._y))
, _z(z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d::GxVector3d(const GxVector2d& vector, f64 z)
: _x(vector._x)
, _y(vector._y)
, _z(z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d::GxVector3d(const GxVector4d& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
{
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d::GxVector3d(const GxVector3d& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator = (const GxVector3d& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator += (f64 scalar)
{
    addScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator -= (f64 scalar)
{
    subScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator *= (f64 scalar)
{
    mulScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator /= (f64 scalar)
{
    divScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator += (const GxVector3d& vector)
{
    addVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator -= (const GxVector3d& vector)
{
    subVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator *= (const GxVector3d& vector)
{
    mulVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d& GxVector3d::operator /= (const GxVector3d& vector)
{
    divVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d operator + (const GxVector3d& vector, f64 scalar)
{
    GxVector3d result;
    return GxVector3d::getAddScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d operator - (const GxVector3d& vector, f64 scalar)
{
    GxVector3d result;
    return GxVector3d::getSubScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_INLINE const GxVector3d operator * (const GxVector3d& vector, f64 scalar)
{
    GxVector3d result;
    return GxVector3d::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d operator * (f64 scalar, const GxVector3d& vector)
{
    GxVector3d result;
    return GxVector3d::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d operator / (const GxVector3d& vector, f64 scalar)
{
    GxVector3d result;
    return GxVector3d::getDivScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d operator + (const GxVector3d& vector0, const GxVector3d& vector1)
{
    GxVector3d result;
    return GxVector3d::getAddVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d operator - (const GxVector3d& vector0, const GxVector3d& vector1)
{
    GxVector3d result;
    return GxVector3d::getSubVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d operator * (const GxVector3d& vector0, const GxVector3d& vector1)
{
    GxVector3d result;
    return GxVector3d::getMulVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d operator / (const GxVector3d& vector0, const GxVector3d& vector1)
{
    GxVector3d result;
    return GxVector3d::getDivVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxVector3d& vector0, const GxVector3d& vector1)
{
    return (vector0._x == vector1._x) && (vector0._y == vector1._y) && (vector0._z == vector1._z);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxVector3d& vector0, const GxVector3d& vector1)
{
    return (vector0._x != vector1._x) || (vector0._y != vector1._y) || (vector0._z != vector1._z);
}
 
//---------------------------------------------------------------------------
// const配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE const f64& GxVector3d::operator[](u32 i) const
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// 配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64& GxVector3d::operator[](u32 i)
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// XY要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getXY(void) const
{
    return GxVector3d(_x, _y, 0.0);
}
 
//---------------------------------------------------------------------------
// XY要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getXY(GxVector3d& dst) const
{
    dst._x = _x;
    dst._y = _y;
    dst._z = 0.0;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// XY要素のベクトルを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3d::setXY(const GxVector3d& vector)
{
    _x = vector._x;
    _y = vector._y;
}
 
//---------------------------------------------------------------------------
// XZ要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getXZ(void) const
{
    return GxVector3d(_x, 0.0, _z);
}
 
//---------------------------------------------------------------------------
// XZ要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getXZ(GxVector3d& dst) const
{
    dst._x = _x;
    dst._y = 0.0;
    dst._z = _z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// XZ要素のベクトルを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3d::setXZ(const GxVector3d& vector)
{
    _x = vector._x;
    _z = vector._z;
}
 
//---------------------------------------------------------------------------
// YZ要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getYZ(void) const
{
    return GxVector3d(0.0, _y, _z);
}
 
//---------------------------------------------------------------------------
// YZ要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getYZ(GxVector3d& dst) const
{
    dst._x = 0.0;
    dst._y = _y;
    dst._z = _z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// YZ要素のベクトルを設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3d::setYZ(const GxVector3d& vector)
{
    _y = vector._y;
    _z = vector._z;
}
 
//---------------------------------------------------------------------------
// ゼロベクトルか判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector3d::isZeroVector(void) const
{
    return (getLengthSquare() <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE);
}
 
//---------------------------------------------------------------------------
// 長さを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector3d::getLength(void) const
{
    return GxMath::getSqrt(getLengthSquare());
}
 
//---------------------------------------------------------------------------
// 長さの2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector3d::getLengthSquare(void) const
{
    return _x * _x + _y * _y + _z * _z;
}
 
//---------------------------------------------------------------------------
// 長さを設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3d::setLength(f64 length)
{
    auto oldLength = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < oldLength * oldLength, "ゼロベクトルに長さを設定しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (oldLength * oldLength <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        oldLength = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( oldLength * oldLength <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルに長さを設定しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        oldLength = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto scale = length / oldLength;
 
    _x *= scale;
    _y *= scale;
    _z *= scale;
}
 
//---------------------------------------------------------------------------
// 長さを設定(長さ0に対応)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3d::setLengthEx(f64 length)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto scale = length / GxMath::getSqrt(lengthSquare);
 
        _x *= scale;
        _y *= scale;
        _z *= scale;
    }
    else
    {
        _x = 0.0;
        _y = 0.0;
        _z = 0.0;
    }
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getNormalize(void) const
{
    auto length = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length * length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )      length = 1.0;
#else // GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
 
    return GxVector3d(
        _x * inverseLength,
        _y * inverseLength,
        _z * inverseLength);
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getNormalizeEx(void) const
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
 
        return GxVector3d(
            _x * inverseLength,
            _y * inverseLength,
            _z * inverseLength);
    }
    else
    {
        return GxVector3d(
            0.0,
            0.0,
            0.0);
    }
}
 
//---------------------------------------------------------------------------
// スカラ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getAddScalar(GxVector3d& dst, const GxVector3d& vector, f64 scalar)
{
    dst._x = vector._x + scalar;
    dst._y = vector._y + scalar;
    dst._z = vector._z + scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getSubScalar(GxVector3d& dst, const GxVector3d& vector, f64 scalar)
{
    dst._x = vector._x - scalar;
    dst._y = vector._y - scalar;
    dst._z = vector._z - scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getMulScalar(GxVector3d& dst, const GxVector3d& vector, f64 scalar)
{
    dst._x = vector._x * scalar;
    dst._y = vector._y * scalar;
    dst._z = vector._z * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getDivScalar(GxVector3d& dst, const GxVector3d& vector, f64 scalar)
{
    auto inverseScalar = 1.0 / scalar;
 
    dst._x = vector._x * inverseScalar;
    dst._y = vector._y * inverseScalar;
    dst._z = vector._z * inverseScalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getAddVector(GxVector3d& dst, const GxVector3d& vector0, const GxVector3d& vector1)
{
    dst._x = vector0._x + vector1._x;
    dst._y = vector0._y + vector1._y;
    dst._z = vector0._z + vector1._z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getSubVector(GxVector3d& dst, const GxVector3d& vector0, const GxVector3d& vector1)
{
    dst._x = vector0._x - vector1._x;
    dst._y = vector0._y - vector1._y;
    dst._z = vector0._z - vector1._z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getMulVector(GxVector3d& dst, const GxVector3d& vector0, const GxVector3d& vector1)
{
    dst._x = vector0._x * vector1._x;
    dst._y = vector0._y * vector1._y;
    dst._z = vector0._z * vector1._z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getDivVector(GxVector3d& dst, const GxVector3d& vector0, const GxVector3d& vector1)
{
    dst._x = vector0._x / vector1._x;
    dst._y = vector0._y / vector1._y;
    dst._z = vector0._z / vector1._z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getNormalize(GxVector3d& dst, const GxVector3d& vector)
{
    auto length = vector.getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length * length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        length = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
 
    dst._x = vector._x * inverseLength;
    dst._y = vector._y * inverseLength;
    dst._z = vector._z * inverseLength;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getNormalizeEx(GxVector3d& dst, const GxVector3d& vector)
{
    const auto lengthSquare = vector.getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
 
        dst._x = vector._x * inverseLength;
        dst._y = vector._y * inverseLength;
        dst._z = vector._z * inverseLength;
    }
    else
    {
        dst._x = 0.0;
        dst._y = 0.0;
        dst._z = 0.0;
    }
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 内積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector3d::getDot(const GxVector3d& vector0, const GxVector3d& vector1)
{
    return vector0._x * vector1._x + vector0._y * vector1._y + vector0._z * vector1._z;
}
 
//---------------------------------------------------------------------------
// 外積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getCross(const GxVector3d& vector0, const GxVector3d& vector1)
{
    return GxVector3d(  vector0._y * vector1._z - vector0._z * vector1._y,
                        vector0._z * vector1._x - vector0._x * vector1._z,
                        vector0._x * vector1._y - vector0._y * vector1._x);
}
 
//---------------------------------------------------------------------------
// 外積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getCross(GxVector3d& dst, const GxVector3d& vector0, const GxVector3d& vector1)
{
    dst._x = vector0._y * vector1._z - vector0._z * vector1._y;
    dst._y = vector0._z * vector1._x - vector0._x * vector1._z;
    dst._z = vector0._x * vector1._y - vector0._y * vector1._x;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 直交する単位ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getCrossVector(const GxVector3d& vector)
{
    GxVector3d temporary(vector._z, -vector._x, vector._y);
    if(GxVector3d::getDot(vector, temporary) <= -1.0 + DBL_EPSILON)
    {
        // 真逆
        temporary._x = -temporary._x;
    }
 
    GxVector3d result;
    GxVector3d::getCross(result, vector, temporary);
 
    return result.normalizeEx();
}
 
//---------------------------------------------------------------------------
// 直交する単位ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getCrossVector(GxVector3d& dst, const GxVector3d& vector)
{
    GxVector3d temporary(vector._z, -vector._x, vector._y);
    if(GxVector3d::getDot(vector, temporary) <= -1.0 + DBL_EPSILON)
    {
        // 真逆
        temporary._x = -temporary._x;
    }
 
    GxVector3d::getCross(dst, vector, temporary);
 
    return dst.normalizeEx();
}
 
//---------------------------------------------------------------------------
// 距離を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector3d::getDistance(const GxVector3d& vector0, const GxVector3d& vector1)
{
    return GxMath::getSqrt(getDistanceSquare(vector0, vector1));
}
 
//---------------------------------------------------------------------------
// 距離の2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector3d::getDistanceSquare(const GxVector3d& vector0, const GxVector3d& vector1)
{
    const auto x = vector0._x - vector1._x;
    const auto y = vector0._y - vector1._y;
    const auto z = vector0._z - vector1._z;
 
    return x * x + y * y + z * z;
}
 
//---------------------------------------------------------------------------
// 角度差を取得(符号なし radian)
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector3d::getAngle(const GxVector3d& vector0, const GxVector3d& vector1)
{
    const auto denominator = vector0.getLengthSquare() * vector1.getLengthSquare();
 
    if( denominator <= DBL_EPSILON)
    {
        return 0.0;
    }
 
    const auto value = GxMath::getClamp(getDot(vector0, vector1) / GxMath::getSqrt(denominator), -1.0, 1.0);
    return GxMath::getACos(value);
}
 
//---------------------------------------------------------------------------
// 角度差を取得(符号つき radian)
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector3d::getAngle(const GxVector3d& vector0, const GxVector3d& vector1, const GxVector3d& up)
{
    const auto denominator = vector0.getLengthSquare() * vector1.getLengthSquare();
 
    if(denominator <= DBL_EPSILON)
    {
        return 0.0;
    }
 
    const auto value = GxMath::getClamp(getDot(vector0, vector1) / GxMath::getSqrt(denominator), -1.0, 1.0);
 
    GxVector3d vector2;
    const auto signe = getDot(up, getCross(vector2, vector0, vector1));
    
    return (0.0 <= signe) ? GxMath::getACos(value) : -GxMath::getACos(value);
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getMinimum(const GxVector3d& vector0, const GxVector3d& vector1)
{
    return GxVector3d(vector0._x < vector1._x ? vector0._x : vector1._x,
                     vector0._y < vector1._y ? vector0._y : vector1._y,
                     vector0._z < vector1._z ? vector0._z : vector1._z);
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getMinimum(GxVector3d& dst, const GxVector3d& vector0, const GxVector3d& vector1)
{
    dst._x = vector0._x < vector1._x ? vector0._x : vector1._x;
    dst._y = vector0._y < vector1._y ? vector0._y : vector1._y;
    dst._z = vector0._z < vector1._z ? vector0._z : vector1._z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 要素毎に最大値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getMaximum(const GxVector3d& vector0, const GxVector3d& vector1)
{
    return GxVector3d(vector0._x > vector1._x ? vector0._x : vector1._x,
                     vector0._y > vector1._y ? vector0._y : vector1._y,
                     vector0._z > vector1._z ? vector0._z : vector1._z);
}
 
//---------------------------------------------------------------------------
// 要素毎に最大値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getMaximum(GxVector3d& dst, const GxVector3d& vector0, const GxVector3d& vector1)
{
    dst._x = vector0._x > vector1._x ? vector0._x : vector1._x;
    dst._y = vector0._y > vector1._y ? vector0._y : vector1._y;
    dst._z = vector0._z > vector1._z ? vector0._z : vector1._z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 線形補間
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getLerp(const GxVector3d& vector0, const GxVector3d& vector1, f64 t)
{
    return GxVector3d(vector0._x + (vector1._x - vector0._x) * t,
                     vector0._y + (vector1._y - vector0._y) * t,
                     vector0._z + (vector1._z - vector0._z) * t);
}
 
//---------------------------------------------------------------------------
// 線形補間
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getLerp(GxVector3d& dst, const GxVector3d& vector0, const GxVector3d& vector1, f64 t)
{
    dst._x = vector0._x + (vector1._x - vector0._x) * t;
    dst._y = vector0._y + (vector1._y - vector0._y) * t;
    dst._z = vector0._z + (vector1._z - vector0._z) * t;
 
    return dst;
}
 
//---------------------------------------------------------------------------
//  指定した点が線分上のどこに位置するかのパラメータを返す
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector3d::getLineParam(const GxVector3d& checkPosition, const GxVector3d& startPosition, const GxVector3d& endPosition)
{
    GxVector3d v0(endPosition - startPosition);
    GxVector3d v1(checkPosition - startPosition);
    auto numerator = GxVector3d::getDot(v0, v1);
    auto denominator = GxVector3d::getDot(v0, v0);
 
    // 線分の長さが無いときは 0
    if( denominator <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        return 0.0;
    }
 
    return numerator / denominator;
}
 
//---------------------------------------------------------------------------
//  指定した点を直線上に下ろした点を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getLinePosition(GxVector3d& dst, const GxVector3d& position, const GxVector3d& linePosition0, const GxVector3d& linePosition1)
{
    auto t = getLineParam(position, linePosition0, linePosition1);
 
    return GxVector3d::getLerp(dst, linePosition0, linePosition1, t);
}
 
//---------------------------------------------------------------------------
// 指定した点を直線上に下ろした点を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getLinePosition(const GxVector3d& position, const GxVector3d& linePosition0, const GxVector3d& linePosition1)
{
    auto t = getLineParam(position, linePosition0, linePosition1);
 
    return GxVector3d::getLerp(linePosition0, linePosition1, t);
}
 
//---------------------------------------------------------------------------
//  指定した点を線分上に下ろした点を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::getSegmentPosition(GxVector3d& dst, const GxVector3d& position, const GxVector3d& startPosition, const GxVector3d& endPosition)
{
    auto t = getLineParam(position, startPosition, endPosition);
    t = GxMath::getClamp(t, 0.0, 1.0);
 
    return GxVector3d::getLerp(dst, startPosition, endPosition, t);
}
 
//---------------------------------------------------------------------------
// 指定した点を線分上に下ろした点を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3d GxVector3d::getSegmentPosition(const GxVector3d& position, const GxVector3d& startPosition, const GxVector3d& endPosition)
{
    auto t = getLineParam(position, startPosition, endPosition);
    t = GxMath::getClamp(t, 0.0, 1.0);
 
    return GxVector3d::getLerp(startPosition, endPosition, t);
}
 
//---------------------------------------------------------------------------
// ベクトルが同じ方向を向いているか（ラジアン指定／指定値以内なら(==も含む)同じ方向）
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector3d::isSameDirectionLessEqual( const GxVector3d& vector0, const GxVector3d& vector1, f64 limitRadian )
{
    const auto dot = GxVector3d::getDot(vector0, vector1);
    const auto cosRadian = GxMath::getCos(limitRadian);
 
    if( dot > 0.f )
    {
        if( cosRadian <= 0.f )
        {
            return true;
        }
        else if( dot * dot >= vector0.getLengthSquare() * vector1.getLengthSquare() * cosRadian * cosRadian )
        {
            return true;
        }
    }
    else
    {
        if( cosRadian <= 0.f &&
            dot * dot <= vector0.getLengthSquare() * vector1.getLengthSquare() * cosRadian * cosRadian )
        {
            return true;
        }
    }
 
    return false;
}
 
//---------------------------------------------------------------------------
// ベクトルが同じ方向を向いているか（ラジアン指定／指定値より小さければ(==は含まない)同じ方向）
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector3d::isSameDirectionLessThan( const GxVector3d& vector0, const GxVector3d& vector1, f64 limitRadian )
{
    const auto dot = GxVector3d::getDot(vector0, vector1);
    const auto cosRadian = GxMath::getCos(limitRadian);
 
    if( dot > 0.f )
    {
        if( cosRadian < 0.f )
        {
            return true;
        }
        else if( dot * dot > vector0.getLengthSquare() * vector1.getLengthSquare() * cosRadian * cosRadian )
        {
            return true;
        }
    }
    else
    {
        if( cosRadian < 0.f &&
            dot * dot < vector0.getLengthSquare() * vector1.getLengthSquare() * cosRadian * cosRadian )
        {
            return true;
        }
    }
 
    return false;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::addScalar(f64 scalar)
{
    _x += scalar;
    _y += scalar;
    _z += scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::subScalar(f64 scalar)
{
    _x -= scalar;
    _y -= scalar;
    _z -= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::mulScalar(f64 scalar)
{
    _x *= scalar;
    _y *= scalar;
    _z *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::divScalar(f64 scalar)
{
    auto inverseScalar = 1.0 / scalar;
 
    _x *= inverseScalar;
    _y *= inverseScalar;
    _z *= inverseScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::addVector(const GxVector3d& vector)
{
    _x += vector._x;
    _y += vector._y;
    _z += vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::subVector(const GxVector3d& vector)
{
    _x -= vector._x;
    _y -= vector._y;
    _z -= vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::mulVector(const GxVector3d& vector)
{
    _x *= vector._x;
    _y *= vector._y;
    _z *= vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::divVector(const GxVector3d& vector)
{
    _x /= vector._x;
    _y /= vector._y;
    _z /= vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::normalize(void)
{
    auto length = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length * length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        length = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
 
    _x *= inverseLength;
    _y *= inverseLength;
    _z *= inverseLength;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3d& GxVector3d::normalizeEx(void)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const f64 inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
 
        _x *= inverseLength;
        _y *= inverseLength;
        _z *= inverseLength;
    }
    else
    {
        _x = 0.0;
        _y = 0.0;
        _z = 0.0;
    }
 
    return *this;
}
 
//===========================================================================
// GxVector4d
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d::GxVector4d(f64 x, f64 y, f64 z, f64 w)
: _x(x)
, _y(y)
, _z(z)
, _w(w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d::GxVector4d(const GxDouble4& double4)
: _x(double4._x)
, _y(double4._y)
, _z(double4._z)
, _w(double4._w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d::GxVector4d(const f64* pDoubleArray)
: _x(pDoubleArray[0])
, _y(pDoubleArray[1])
, _z(pDoubleArray[2])
, _w(pDoubleArray[3])
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d::GxVector4d(const GxVector3d& vector, f64 w)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
, _w(w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d::GxVector4d(const GxColorHDR& color)
: _x(color._red)
, _y(color._green)
, _z(color._blue)
, _w(color._alpha)
{
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d::GxVector4d(const GxVector4d& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
, _w(vector._w)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator = (const GxVector3d& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator = (const GxVector4d& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    _w = vector._w;
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator += (f64 scalar)
{
    addScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator -= (f64 scalar)
{
    subScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator *= (f64 scalar)
{
    mulScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator /= (f64 scalar)
{
    divScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator += (const GxVector4d& vector)
{
    addVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator -= (const GxVector4d& vector)
{
    subVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator *= (const GxVector4d& vector)
{
    mulVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d& GxVector4d::operator /= (const GxVector4d& vector)
{
    divVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator + (const GxVector4d& vector, f64 scalar)
{
    GxVector4d result;
    return GxVector4d::getAddScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator - (const GxVector4d& vector, f64 scalar)
{
    GxVector4d result;
    return GxVector4d::getSubScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator * (const GxVector4d& vector, f64 scalar)
{
    GxVector4d result;
    return GxVector4d::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator * (f64 scalar, const GxVector4d& vector)
{
    GxVector4d result;
    return GxVector4d::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator / (const GxVector4d& vector, f64 scalar)
{
    GxVector4d result;
    return GxVector4d::getDivScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator + (const GxVector4d& vector0, const GxVector4d& vector1)
{
    GxVector4d result;
    return GxVector4d::getAddVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator - (const GxVector4d& vector0, const GxVector4d& vector1)
{
    GxVector4d result;
    return GxVector4d::getSubVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator * (const GxVector4d& vector0, const GxVector4d& vector1)
{
    GxVector4d result;
    return GxVector4d::getMulVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d operator / (const GxVector4d& vector0, const GxVector4d& vector1)
{
    GxVector4d result;
    return GxVector4d::getDivVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxVector4d& vector0, const GxVector4d& vector1)
{
    return (vector0._x == vector1._x) && (vector0._y == vector1._y) && (vector0._z == vector1._z) && (vector0._w == vector1._w);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxVector4d& vector0, const GxVector4d& vector1)
{
    return (vector0._x != vector1._x) || (vector0._y != vector1._y) || (vector0._z != vector1._z) || (vector0._w != vector1._w);
}
 
//---------------------------------------------------------------------------
// const配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE const f64& GxVector4d::operator[](u32 i) const
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// 配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64& GxVector4d::operator[](u32 i)
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// ゼロベクトル判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector4d::isZeroVector(void) const
{
    return (getLengthSquare() <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE);
}
 
//---------------------------------------------------------------------------
// 長さを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector4d::getLength(void) const
{
    return GxMath::getSqrt(getLengthSquare());
}
 
//---------------------------------------------------------------------------
// 長さの2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector4d::getLengthSquare(void) const
{
    return _x * _x + _y * _y + _z * _z + _w * _w;
}
 
//---------------------------------------------------------------------------
// 長さを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector4d::setLength(f64 length)
{
    auto oldLength = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < oldLength * oldLength, "ゼロベクトルに長さを設定しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (oldLength * oldLength <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        oldLength = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( oldLength * oldLength <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルに長さを設定しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        oldLength = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto scale = length / oldLength;
 
    _x *= scale;
    _y *= scale;
    _z *= scale;
    _w *= scale;
}
 
//---------------------------------------------------------------------------
// 長さを設定(長さ0に対応)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector4d::setLengthEx(f64 length)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto scale = length / GxMath::getSqrt(lengthSquare);
 
        _x *= scale;
        _y *= scale;
        _z *= scale;
        _w *= scale;
    }
    else
    {
        _x = 0.0;
        _y = 0.0;
        _z = 0.0;
        _w = 0.0;
    }
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d GxVector4d::getNormalize(void) const
{
    auto length = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length * length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        length = 1.0;
    }
#else // GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
 
    return GxVector4d(_x * inverseLength, _y * inverseLength, _z * inverseLength, _w * inverseLength);
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d GxVector4d::getNormalizeEx(void) const
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
        return GxVector4d(_x * inverseLength, _y * inverseLength, _z * inverseLength, _w * inverseLength);
    }
    return GxVector4d::ZERO;
}
 
//---------------------------------------------------------------------------
// スカラ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getAddScalar(GxVector4d& dst, const GxVector4d& vector, f64 scalar)
{
    dst._x = vector._x + scalar;
    dst._y = vector._y + scalar;
    dst._z = vector._z + scalar;
    dst._w = vector._w + scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getSubScalar(GxVector4d& dst, const GxVector4d& vector, f64 scalar)
{
    dst._x = vector._x - scalar;
    dst._y = vector._y - scalar;
    dst._z = vector._z - scalar;
    dst._w = vector._w - scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getMulScalar(GxVector4d& dst, const GxVector4d& vector, f64 scalar)
{
    dst._x = vector._x * scalar;
    dst._y = vector._y * scalar;
    dst._z = vector._z * scalar;
    dst._w = vector._w * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getDivScalar(GxVector4d& dst, const GxVector4d& vector, f64 scalar)
{
    auto inverseScalar = 1.0 / scalar;
 
    dst._x = vector._x * inverseScalar;
    dst._y = vector._y * inverseScalar;
    dst._z = vector._z * inverseScalar;
    dst._w = vector._w * inverseScalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getAddVector(GxVector4d& dst, const GxVector4d& vector0, const GxVector4d& vector1)
{
    dst._x = vector0._x + vector1._x;
    dst._y = vector0._y + vector1._y;
    dst._z = vector0._z + vector1._z;
    dst._w = vector0._w + vector1._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getSubVector(GxVector4d& dst, const GxVector4d& vector0, const GxVector4d& vector1)
{
    dst._x = vector0._x - vector1._x;
    dst._y = vector0._y - vector1._y;
    dst._z = vector0._z - vector1._z;
    dst._w = vector0._w - vector1._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getMulVector(GxVector4d& dst, const GxVector4d& vector0, const GxVector4d& vector1)
{
    dst._x = vector0._x * vector1._x;
    dst._y = vector0._y * vector1._y;
    dst._z = vector0._z * vector1._z;
    dst._w = vector0._w * vector1._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getDivVector(GxVector4d& dst, const GxVector4d& vector0, const GxVector4d& vector1)
{
    dst._x = vector0._x / vector1._x;
    dst._y = vector0._y / vector1._y;
    dst._z = vector0._z / vector1._z;
    dst._w = vector0._w / vector1._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getNormalize(GxVector4d& dst, const GxVector4d& vector)
{
    auto length = vector.getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length* length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        length = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
 
    dst._x = vector._x * inverseLength;
    dst._y = vector._y * inverseLength;
    dst._z = vector._z * inverseLength;
    dst._w = vector._w * inverseLength;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getNormalizeEx(GxVector4d& dst, const GxVector4d& vector)
{
    const auto lengthSquare = vector.getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
 
        dst._x = vector._x * inverseLength;
        dst._y = vector._y * inverseLength;
        dst._z = vector._z * inverseLength;
        dst._w = vector._w * inverseLength;
    }
    else
    {
        dst._x = 0.0;
        dst._y = 0.0;
        dst._z = 0.0;
        dst._w = 0.0;
    }
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 内積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f64 GxVector4d::getDot(const GxVector4d& vector0, const GxVector4d& vector1)
{
    return vector0._x * vector1._x + vector0._y * vector1._y + vector0._z * vector1._z + vector0._w * vector1._w;
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d GxVector4d::getMinimum(const GxVector4d& vector0, const GxVector4d& vector1)
{
    return GxVector4d(vector0._x < vector1._x ? vector0._x : vector1._x,
                     vector0._y < vector1._y ? vector0._y : vector1._y,
                     vector0._z < vector1._z ? vector0._z : vector1._z,
                     vector0._w < vector1._w ? vector0._w : vector1._w);
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getMinimum(GxVector4d& dst, const GxVector4d& vector0, const GxVector4d& vector1)
{
    dst._x = vector0._x < vector1._x ? vector0._x : vector1._x;
    dst._y = vector0._y < vector1._y ? vector0._y : vector1._y;
    dst._z = vector0._z < vector1._z ? vector0._z : vector1._z;
    dst._w = vector0._w < vector1._w ? vector0._w : vector1._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 要素毎に最大値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d GxVector4d::getMaximum(const GxVector4d& vector0, const GxVector4d& vector1)
{
    return GxVector4d(vector0._x > vector1._x ? vector0._x : vector1._x,
                     vector0._y > vector1._y ? vector0._y : vector1._y,
                     vector0._z > vector1._z ? vector0._z : vector1._z,
                     vector0._w > vector1._w ? vector0._w : vector1._w);
}
 
//---------------------------------------------------------------------------
// 要素毎に最大値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getMaximum(GxVector4d& dst, const GxVector4d& vector0, const GxVector4d& vector1)
{
    dst._x = vector0._x > vector1._x ? vector0._x : vector1._x;
    dst._y = vector0._y > vector1._y ? vector0._y : vector1._y;
    dst._z = vector0._z > vector1._z ? vector0._z : vector1._z;
    dst._w = vector0._w > vector1._w ? vector0._w : vector1._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 線形補間
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4d GxVector4d::getLerp(const GxVector4d& vector0, const GxVector4d& vector1, f64 t)
{
    return GxVector4d(vector0._x + (vector1._x - vector0._x) * t,
                     vector0._y + (vector1._y - vector0._y) * t,
                     vector0._z + (vector1._z - vector0._z) * t,
                     vector0._w + (vector1._w - vector0._w) * t);
}
 
//---------------------------------------------------------------------------
// 線形補間
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::getLerp(GxVector4d& dst, const GxVector4d& vector0, const GxVector4d& vector1, f64 t)
{
    dst._x = vector0._x + (vector1._x - vector0._x) * t;
    dst._y = vector0._y + (vector1._y - vector0._y) * t;
    dst._z = vector0._z + (vector1._z - vector0._z) * t;
    dst._w = vector0._w + (vector1._w - vector0._w) * t;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::addScalar(f64 scalar)
{
    _x += scalar;
    _y += scalar;
    _z += scalar;
    _w += scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::subScalar(f64 scalar)
{
    _x -= scalar;
    _y -= scalar;
    _z -= scalar;
    _w -= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::mulScalar(f64 scalar)
{
    _x *= scalar;
    _y *= scalar;
    _z *= scalar;
    _w *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::divScalar(f64 scalar)
{
    auto inverseScalar = 1.0 / scalar;
 
    _x *= inverseScalar;
    _y *= inverseScalar;
    _z *= inverseScalar;
    _w *= inverseScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::addVector(const GxVector4d& vector)
{
    _x += vector._x;
    _y += vector._y;
    _z += vector._z;
    _w += vector._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::subVector(const GxVector4d& vector)
{
    _x -= vector._x;
    _y -= vector._y;
    _z -= vector._z;
    _w -= vector._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::mulVector(const GxVector4d& vector)
{
    _x *= vector._x;
    _y *= vector._y;
    _z *= vector._z;
    _w *= vector._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::divVector(const GxVector4d& vector)
{
    _x /= vector._x;
    _y /= vector._y;
    _z /= vector._z;
    _w /= vector._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::normalize(void)
{
    auto length = getLength();
 
#if GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    GX_ERROR(GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < length * length, "ゼロベクトルを正規化しようとしました");
 
    //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
    if (length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE)
    {
        length = 1.0;
    }
#else //GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
    if( length * length <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "%s(%d)", __FILE__, __LINE__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "[%s]", __FUNCTION__);
        GX_TRACE(GX_TRACE_CATEGORY_CORE, "ゼロベクトルを正規化しようとしました");
 
        //このまま進んでしまうと0除算が発生したまま処理が進みINF等になるため1.0に補正
        length = 1.0;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0 / length;
    _x *= inverseLength;
    _y *= inverseLength;
    _z *= inverseLength;
    _w *= inverseLength;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4d& GxVector4d::normalizeEx(void)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0 / GxMath::getSqrt(lengthSquare);
        _x *= inverseLength;
        _y *= inverseLength;
        _z *= inverseLength;
        _w *= inverseLength;
    }
    else
    {
        _x = 0.0;
        _y = 0.0;
        _z = 0.0;
        _w = 0.0;
    }
 
    return *this;
}
 
#undef GX_VECTOR_ZERO_VECTOR_CHECK_VALUE
 
GX_CORE_NAMESPACE_END()