GxVector.inl

Go to the documentation of this file.

//===========================================================================
//===========================================================================
 
GX_CORE_NAMESPACE_BEGIN()
 
#define GX_VECTOR_ZERO_VECTOR_CHECK_VALUE   F32_ABS_MIN     // ゼロベクトルをチェックする定数
 
//===========================================================================
// GxVector2
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2::GxVector2(f32 x, f32 y)
: _x(x)
, _y(y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2::GxVector2(const GxFloat2& float2)
: _x(float2._x)
, _y(float2._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2::GxVector2(const f32* pFloatArray)
: _x(pFloatArray[0])
, _y(pFloatArray[1])
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2::GxVector2(const GxPoint2& point)
: _x(static_cast<f32>(point._x))
, _y(static_cast<f32>(point._y))
{
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2::GxVector2(const GxVector2& vector)
: _x(vector._x)
, _y(vector._y)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator = (const GxVector2& vector)
{
    _x = vector._x;
    _y = vector._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator += (f32 scalar)
{
    addScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator -= (f32 scalar)
{
    subScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator *= (f32 scalar)
{
    mulScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator /= (f32 scalar)
{
    divScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator += (const GxVector2& vector)
{
    addVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator -= (const GxVector2& vector)
{
    subVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator *= (const GxVector2& vector)
{
    mulVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2& GxVector2::operator /= (const GxVector2& vector)
{
    divVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator + (const GxVector2& vector, f32 scalar)
{
    GxVector2 result;
    return GxVector2::getAddScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator - (const GxVector2& vector, f32 scalar)
{
    GxVector2 result;
    return GxVector2::getSubScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator * (const GxVector2& vector, f32 scalar)
{
    GxVector2 result;
    return GxVector2::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator * (f32 scalar, const GxVector2& vector)
{
    GxVector2 result;
    return GxVector2::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator / (const GxVector2& vector, f32 scalar)
{
    GxVector2 result;
    return GxVector2::getDivScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator + (const GxVector2& vector0, const GxVector2& vector1)
{
    GxVector2 result;
    return GxVector2::getAddVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator - (const GxVector2& vector0, const GxVector2& vector1)
{
    GxVector2 result;
    return GxVector2::getSubVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator * (const GxVector2& vector0, const GxVector2& vector1)
{
    GxVector2 result;
    return GxVector2::getMulVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2 operator / (const GxVector2& vector0, const GxVector2& vector1)
{
    GxVector2 result;
    return GxVector2::getDivVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxVector2& vector0, const GxVector2& vector1)
{
    return (vector0._x == vector1._x) && (vector0._y == vector1._y);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxVector2& vector0, const GxVector2& vector1)
{
    return (vector0._x != vector1._x) || (vector0._y != vector1._y);
}
 
//---------------------------------------------------------------------------
// const配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE const f32& GxVector2::operator[](u32 i) const
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// 配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32& GxVector2::operator[](u32 i)
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// ゼロベクトル判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector2::isZeroVector(void) const
{
    return (getLengthSquare() <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE);
}
 
//---------------------------------------------------------------------------
// 長さを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector2::getLength(void) const
{
    return GxMath::getSqrt(getLengthSquare());
}
 
//---------------------------------------------------------------------------
// 長さの2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector2::getLengthSquare(void) const
{
    return _x * _x + _y * _y;
}
 
//---------------------------------------------------------------------------
// 長さを設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector2::setLength(f32 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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto scale = length / oldLength;
 
    _x *= scale;
    _y *= scale;
}
 
//---------------------------------------------------------------------------
// 長さを設定(長さ0に対応)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector2::setLengthEx(f32 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.0f;
        _y = 0.0f;
    }
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2 GxVector2::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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / length;
 
    return GxVector2(_x * inverseLength, _y * inverseLength);
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2 GxVector2::getNormalizeEx(void) const
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
 
        return GxVector2(_x * inverseLength, _y * inverseLength);
    }
    else
    {
        return GxVector2::ZERO;
    }
}
 
//---------------------------------------------------------------------------
// スカラ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getAddScalar(GxVector2& dst, const GxVector2& vector, f32 scalar)
{
    dst._x = vector._x + scalar;
    dst._y = vector._y + scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getSubScalar(GxVector2& dst, const GxVector2& vector, f32 scalar)
{
    dst._x = vector._x - scalar;
    dst._y = vector._y - scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getMulScalar(GxVector2& dst, const GxVector2& vector, f32 scalar)
{
    dst._x = vector._x * scalar;
    dst._y = vector._y * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getDivScalar(GxVector2& dst, const GxVector2& vector, f32 scalar)
{
    auto inverseLength = 1.0f / scalar;
 
    dst._x = vector._x * inverseLength;
    dst._y = vector._y * inverseLength;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getAddVector(GxVector2& dst, const GxVector2& vector0, const GxVector2& vector1)
{
    dst._x = vector0._x + vector1._x;
    dst._y = vector0._y + vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getSubVector(GxVector2& dst, const GxVector2& vector0, const GxVector2& vector1)
{
    dst._x = vector0._x - vector1._x;
    dst._y = vector0._y - vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getMulVector(GxVector2& dst, const GxVector2& vector0, const GxVector2& vector1)
{
    dst._x = vector0._x * vector1._x;
    dst._y = vector0._y * vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getDivVector(GxVector2& dst, const GxVector2& vector0, const GxVector2& vector1)
{
    dst._x = vector0._x / vector1._x;
    dst._y = vector0._y / vector1._y;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getNormalize(GxVector2& dst, const GxVector2& 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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / length;
 
    dst._x = vector._x * inverseLength;
    dst._y = vector._y * inverseLength;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getNormalizeEx(GxVector2& dst, const GxVector2& vector)
{
    const auto lengthSquare = vector.getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
 
        dst._x = vector._x * inverseLength;
        dst._y = vector._y * inverseLength;
    }
    else
    {
        dst._x = 0.0f;
        dst._y = 0.0f;
    }
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 内積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector2::getDot(const GxVector2& vector0, const GxVector2& vector1)
{
    return vector0._x * vector1._x + vector0._y * vector1._y;
}
 
//---------------------------------------------------------------------------
// 外積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector2::getCross(const GxVector2& vector0, const GxVector2& vector1)
{
    return vector0._x * vector1._y - vector0._y * vector1._x;
}
 
//---------------------------------------------------------------------------
// 角度差を取得(符号つき radian)
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector2::getAngle(const GxVector2& vector0, const GxVector2& vector1)
{
    if( vector0.isZeroVector() || vector0.isZeroVector() )
    {
        return 0.0f;
    }
 
    const auto cosTheta = GxVector2::getDot(vector0, vector1);
    const auto sinTheta = GxVector2::getCross(vector0, vector1);
 
    return GxMath::getATan2(sinTheta, cosTheta);
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector2 GxVector2::getMinimum(const GxVector2& vector0, const GxVector2& vector1)
{
    return GxVector2(vector0._x < vector1._x ? vector0._x : vector1._x,
                     vector0._y < vector1._y ? vector0._y : vector1._y);
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getMinimum(GxVector2& dst, const GxVector2& vector0, const GxVector2& 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 GxVector2 GxVector2::getMaximum(const GxVector2& vector0, const GxVector2& vector1)
{
    return GxVector2(vector0._x > vector1._x ? vector0._x : vector1._x,
                     vector0._y > vector1._y ? vector0._y : vector1._y);
}
 
//---------------------------------------------------------------------------
// 要素毎に最大値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getMaximum(GxVector2& dst, const GxVector2& vector0, const GxVector2& 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 GxVector2 GxVector2::getLerp(const GxVector2& vector0, const GxVector2& vector1, f32 t)
{
    return GxVector2(vector0._x + (vector1._x - vector0._x) * t,
                     vector0._y + (vector1._y - vector0._y) * t);
}
 
//---------------------------------------------------------------------------
// 線形補間
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::getLerp(GxVector2& dst, const GxVector2& vector0, const GxVector2& vector1, f32 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 GxVector2& GxVector2::addScalar(f32 scalar)
{
    _x += scalar;
    _y += scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::subScalar(f32 scalar)
{
    _x -= scalar;
    _y -= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::mulScalar(f32 scalar)
{
    _x *= scalar;
    _y *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::divScalar(f32 scalar)
{
    auto inverseScalar = 1.0f / scalar;
 
    _x *= inverseScalar;
    _y *= inverseScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::addVector(const GxVector2& vector)
{
    _x += vector._x;
    _y += vector._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::subVector(const GxVector2& vector)
{
    _x -= vector._x;
    _y -= vector._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::mulVector(const GxVector2& vector)
{
    _x *= vector._x;
    _y *= vector._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::divVector(const GxVector2& vector)
{
    _x /= vector._x;
    _y /= vector._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / length;
 
    _x *= inverseLength;
    _y *= inverseLength;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector2& GxVector2::normalizeEx(void)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
 
        _x *= inverseLength;
        _y *= inverseLength;
    }
    else
    {
        _x = 0.0f;
        _y = 0.0f;
    }
 
    return *this;
}
 
//===========================================================================
// GxVector3
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3::GxVector3(f32 x, f32 y, f32 z)
: _x(x)
, _y(y)
, _z(z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3::GxVector3(const GxFloat3& float3)
: _x(float3._x)
, _y(float3._y)
, _z(float3._z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3::GxVector3(const f32* pFloatArray)
: _x(pFloatArray[0])
, _y(pFloatArray[1])
, _z(pFloatArray[2])
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3::GxVector3(const GxPoint2& point, f32 z)
: _x(static_cast<f32>(point._x))
, _y(static_cast<f32>(point._y))
, _z(z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3::GxVector3(const GxVector2& vector, f32 z)
: _x(vector._x)
, _y(vector._y)
, _z(z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3::GxVector3(const GxVector4& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
{
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3::GxVector3(const GxVector3& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator = (const GxVector3& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator += (f32 scalar)
{
    addScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator -= (f32 scalar)
{
    subScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator *= (f32 scalar)
{
    mulScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator /= (f32 scalar)
{
    divScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator += (const GxVector3& vector)
{
    addVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator -= (const GxVector3& vector)
{
    subVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator *= (const GxVector3& vector)
{
    mulVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3& GxVector3::operator /= (const GxVector3& vector)
{
    divVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3 operator + (const GxVector3& vector, f32 scalar)
{
    GxVector3 result;
    return GxVector3::getAddScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3 operator - (const GxVector3& vector, f32 scalar)
{
    GxVector3 result;
    return GxVector3::getSubScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_INLINE const GxVector3 operator * (const GxVector3& vector, f32 scalar)
{
    GxVector3 result;
    return GxVector3::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3 operator * (f32 scalar, const GxVector3& vector)
{
    GxVector3 result;
    return GxVector3::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3 operator / (const GxVector3& vector, f32 scalar)
{
    GxVector3 result;
    return GxVector3::getDivScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3 operator + (const GxVector3& vector0, const GxVector3& vector1)
{
    GxVector3 result;
    return GxVector3::getAddVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3 operator - (const GxVector3& vector0, const GxVector3& vector1)
{
    GxVector3 result;
    return GxVector3::getSubVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3 operator * (const GxVector3& vector0, const GxVector3& vector1)
{
    GxVector3 result;
    return GxVector3::getMulVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3 operator / (const GxVector3& vector0, const GxVector3& vector1)
{
    GxVector3 result;
    return GxVector3::getDivVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxVector3& vector0, const GxVector3& vector1)
{
    return (vector0._x == vector1._x) && (vector0._y == vector1._y) && (vector0._z == vector1._z);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxVector3& vector0, const GxVector3& vector1)
{
    return (vector0._x != vector1._x) || (vector0._y != vector1._y) || (vector0._z != vector1._z);
}
 
//---------------------------------------------------------------------------
// const配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE const f32& GxVector3::operator[](u32 i) const
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// 配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32& GxVector3::operator[](u32 i)
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// XY要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getXY(void) const
{
    return GxVector3(_x, _y, 0.0f);
}
 
//---------------------------------------------------------------------------
// XY要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getXY(GxVector3& dst) const
{
    dst._x = _x;
    dst._y = _y;
    dst._z = 0.0f;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// XY要素のベクトルを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3::setXY(const GxVector3& vector)
{
    _x = vector._x;
    _y = vector._y;
}
 
//---------------------------------------------------------------------------
// XZ要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getXZ(void) const
{
    return GxVector3(_x, 0.0f, _z);
}
 
//---------------------------------------------------------------------------
// XZ要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getXZ(GxVector3& dst) const
{
    dst._x = _x;
    dst._y = 0.0f;
    dst._z = _z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// XZ要素のベクトルを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3::setXZ(const GxVector3& vector)
{
    _x = vector._x;
    _z = vector._z;
}
 
//---------------------------------------------------------------------------
// YZ要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getYZ(void) const
{
    return GxVector3(0.0f, _y, _z);
}
 
//---------------------------------------------------------------------------
// YZ要素のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getYZ(GxVector3& dst) const
{
    dst._x = 0.0f;
    dst._y = _y;
    dst._z = _z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// YZ要素のベクトルを設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3::setYZ(const GxVector3& vector)
{
    _y = vector._y;
    _z = vector._z;
}
 
//---------------------------------------------------------------------------
// ゼロベクトルか判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector3::isZeroVector(void) const
{
    return (getLengthSquare() <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE);
}
 
//---------------------------------------------------------------------------
// 長さを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getLength(void) const
{
    return GxMath::getSqrt(getLengthSquare());
}
 
//---------------------------------------------------------------------------
// 長さの2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getLengthSquare(void) const
{
    return _x * _x + _y * _y + _z * _z;
}
 
//---------------------------------------------------------------------------
// 長さを設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3::setLength(f32 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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto scale = length / oldLength;
 
    _x *= scale;
    _y *= scale;
    _z *= scale;
}
 
//---------------------------------------------------------------------------
// 長さを設定(長さ0に対応)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector3::setLengthEx(f32 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.0f;
        _y = 0.0f;
        _z = 0.0f;
    }
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::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.0f;
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / length;
 
    return GxVector3(
        _x * inverseLength,
        _y * inverseLength,
        _z * inverseLength);
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getNormalizeEx(void) const
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
 
        return GxVector3(
            _x * inverseLength,
            _y * inverseLength,
            _z * inverseLength);
    }
    else
    {
        return GxVector3(
            0.0f,
            0.0f,
            0.0f);
    }
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getTransform(const GxMatrix44& matrix) const
{
    return GxVector3(
        _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0],
        _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1],
        _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2]);
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getTransform(const GxMatrixAffine& matrix) const
{
    return GxVector3(
        _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0],
        _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1],
        _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2]);
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getTransformNormal(const GxMatrix44& matrix) const
{
    return GxVector3(
        _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0],
        _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1],
        _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2]);
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getTransformNormal(const GxMatrixAffine& matrix) const
{
    return GxVector3(
        _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0],
        _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1],
        _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2]);
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換後、wで除算したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getTransformCoord(const GxMatrix44& matrix) const
{
    auto iw = 1.0f / (_x * matrix._m[0][3] + _y * matrix._m[1][3] + _z * matrix._m[2][3] + matrix._m[3][3]);
 
    return GxVector3(
        (_x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0]) * iw,
        (_x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1]) * iw,
        (_x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2]) * iw);
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したx成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformX(const GxMatrix44& matrix) const
{
    return _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0];
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したx成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformX(const GxMatrixAffine& matrix) const
{
    return _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0];
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したx成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformNormalX(const GxMatrix44& matrix) const
{
    return _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0];
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したx成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformNormalX(const GxMatrixAffine& matrix) const
{
    return _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0];
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換後、wで除算したx成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformCoordX(const GxMatrix44& matrix) const
{
    return    (_x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0])
            / (_x * matrix._m[0][3] + _y * matrix._m[1][3] + _z * matrix._m[2][3] + matrix._m[3][3]);
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したy成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformY(const GxMatrix44& matrix) const
{
    return _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1];
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したy成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformY(const GxMatrixAffine& matrix) const
{
    return _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1];
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したy成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformNormalY(const GxMatrix44& matrix) const
{
    return _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1];
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したy成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformNormalY(const GxMatrixAffine& matrix) const
{
    return _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1];
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換後、wで除算したy成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformCoordY(const GxMatrix44& matrix) const
{
    return    (_x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1])
            / (_x * matrix._m[0][3] + _y * matrix._m[1][3] + _z * matrix._m[2][3] + matrix._m[3][3]);
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したz成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformZ(const GxMatrix44& matrix) const
{
    return _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2];
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したz成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformZ(const GxMatrixAffine& matrix) const
{
    return _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2];
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したz成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformNormalZ(const GxMatrix44& matrix) const
{
    return _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2];
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したz成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformNormalZ(const GxMatrixAffine& matrix) const
{
    return _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2];
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換後、wで除算したz成分を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getTransformCoordZ(const GxMatrix44& matrix) const
{
    return    (_x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2])
            / (_x * matrix._m[0][3] + _y * matrix._m[1][3] + _z * matrix._m[2][3] + matrix._m[3][3]);
}
 
//---------------------------------------------------------------------------
// 回転後のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getRotate(const GxQuaternion& quaternion) const
{
    GxQuaternion q(*this, 0.0f);
    q = quaternion * q * quaternion.getConjugate();
    return GxVector3(q._x, q._y, q._z);
}
 
//---------------------------------------------------------------------------
// スカラ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getAddScalar(GxVector3& dst, const GxVector3& vector, f32 scalar)
{
    dst._x = vector._x + scalar;
    dst._y = vector._y + scalar;
    dst._z = vector._z + scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getSubScalar(GxVector3& dst, const GxVector3& vector, f32 scalar)
{
    dst._x = vector._x - scalar;
    dst._y = vector._y - scalar;
    dst._z = vector._z - scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getMulScalar(GxVector3& dst, const GxVector3& vector, f32 scalar)
{
    dst._x = vector._x * scalar;
    dst._y = vector._y * scalar;
    dst._z = vector._z * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getDivScalar(GxVector3& dst, const GxVector3& vector, f32 scalar)
{
    auto inverseScalar = 1.0f / scalar;
 
    dst._x = vector._x * inverseScalar;
    dst._y = vector._y * inverseScalar;
    dst._z = vector._z * inverseScalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ベクトル加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getAddVector(GxVector3& dst, const GxVector3& vector0, const GxVector3& 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 GxVector3& GxVector3::getSubVector(GxVector3& dst, const GxVector3& vector0, const GxVector3& 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 GxVector3& GxVector3::getMulVector(GxVector3& dst, const GxVector3& vector0, const GxVector3& 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 GxVector3& GxVector3::getDivVector(GxVector3& dst, const GxVector3& vector0, const GxVector3& 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 GxVector3& GxVector3::getNormalize(GxVector3& dst, const GxVector3& 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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / length;
 
    dst._x = vector._x * inverseLength;
    dst._y = vector._y * inverseLength;
    dst._z = vector._z * inverseLength;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getNormalizeEx(GxVector3& dst, const GxVector3& vector)
{
    const auto lengthSquare = vector.getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
 
        dst._x = vector._x * inverseLength;
        dst._y = vector._y * inverseLength;
        dst._z = vector._z * inverseLength;
    }
    else
    {
        dst._x = 0.0f;
        dst._y = 0.0f;
        dst._z = 0.0f;
    }
 
    return dst;
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getTransform(GxVector3& dst, const GxVector3& vector, const GxMatrix44& matrix)
{
    dst._x = vector._x * matrix._m[0][0] + vector._y * matrix._m[1][0] + vector._z * matrix._m[2][0] + matrix._m[3][0];
    dst._y = vector._x * matrix._m[0][1] + vector._y * matrix._m[1][1] + vector._z * matrix._m[2][1] + matrix._m[3][1];
    dst._z = vector._x * matrix._m[0][2] + vector._y * matrix._m[1][2] + vector._z * matrix._m[2][2] + matrix._m[3][2];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getTransform(GxVector3& dst, const GxVector3& vector, const GxMatrixAffine& matrix)
{
    dst._x = vector._x * matrix._m[0][0] + vector._y * matrix._m[1][0] + vector._z * matrix._m[2][0] + matrix._m[3][0];
    dst._y = vector._x * matrix._m[0][1] + vector._y * matrix._m[1][1] + vector._z * matrix._m[2][1] + matrix._m[3][1];
    dst._z = vector._x * matrix._m[0][2] + vector._y * matrix._m[1][2] + vector._z * matrix._m[2][2] + matrix._m[3][2];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxFloat3& GxVector3::getTransform(GxFloat3& dst, const GxVector3& vector, const GxMatrix44& matrix)
{
    dst._x = vector._x * matrix._m[0][0] + vector._y * matrix._m[1][0] + vector._z * matrix._m[2][0] + matrix._m[3][0];
    dst._y = vector._x * matrix._m[0][1] + vector._y * matrix._m[1][1] + vector._z * matrix._m[2][1] + matrix._m[3][1];
    dst._z = vector._x * matrix._m[0][2] + vector._y * matrix._m[1][2] + vector._z * matrix._m[2][2] + matrix._m[3][2];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxFloat3& GxVector3::getTransform(GxFloat3& dst, const GxVector3& vector, const GxMatrixAffine& matrix)
{
    dst._x = vector._x * matrix._m[0][0] + vector._y * matrix._m[1][0] + vector._z * matrix._m[2][0] + matrix._m[3][0];
    dst._y = vector._x * matrix._m[0][1] + vector._y * matrix._m[1][1] + vector._z * matrix._m[2][1] + matrix._m[3][1];
    dst._z = vector._x * matrix._m[0][2] + vector._y * matrix._m[1][2] + vector._z * matrix._m[2][2] + matrix._m[3][2];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getTransformNormal(GxVector3& dst, const GxVector3& vector, const GxMatrix44& matrix)
{
    dst._x = vector._x * matrix._m[0][0] + vector._y * matrix._m[1][0] + vector._z * matrix._m[2][0];
    dst._y = vector._x * matrix._m[0][1] + vector._y * matrix._m[1][1] + vector._z * matrix._m[2][1];
    dst._z = vector._x * matrix._m[0][2] + vector._y * matrix._m[1][2] + vector._z * matrix._m[2][2];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// w=0.0として座標変換したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getTransformNormal(GxVector3& dst, const GxVector3& vector, const GxMatrixAffine& matrix)
{
    dst._x = vector._x * matrix._m[0][0] + vector._y * matrix._m[1][0] + vector._z * matrix._m[2][0];
    dst._y = vector._x * matrix._m[0][1] + vector._y * matrix._m[1][1] + vector._z * matrix._m[2][1];
    dst._z = vector._x * matrix._m[0][2] + vector._y * matrix._m[1][2] + vector._z * matrix._m[2][2];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// w=1.0として座標変換後、wで除算したベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getTransformCoord(GxVector3& dst, const GxVector3& vector, const GxMatrix44& matrix)
{
    f32 inverseW = 1.0f / (vector._x * matrix._m[0][3] + vector._y * matrix._m[1][3] + vector._z * matrix._m[2][3] + matrix._m[3][3]);
 
    dst._x = (vector._x * matrix._m[0][0] + vector._y * matrix._m[1][0] + vector._z * matrix._m[2][0] + matrix._m[3][0]) * inverseW;
    dst._y = (vector._x * matrix._m[0][1] + vector._y * matrix._m[1][1] + vector._z * matrix._m[2][1] + matrix._m[3][1]) * inverseW;
    dst._z = (vector._x * matrix._m[0][2] + vector._y * matrix._m[1][2] + vector._z * matrix._m[2][2] + matrix._m[3][2]) * inverseW;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 回転後のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getRotate(GxVector3& dst, const GxVector3& vector, const GxQuaternion& quaternion)
{
    GxQuaternion q(vector, 0.0f);
    q = quaternion * q * quaternion.getConjugate();
 
    dst._x = q._x;
    dst._y = q._y;
    dst._z = q._z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 内積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getDot(const GxVector3& vector0, const GxVector3& vector1)
{
    return vector0._x * vector1._x + vector0._y * vector1._y + vector0._z * vector1._z;
}
 
//---------------------------------------------------------------------------
// 外積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getCross(const GxVector3& vector0, const GxVector3& vector1)
{
    return GxVector3(   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 GxVector3& GxVector3::getCross(GxVector3& dst, const GxVector3& vector0, const GxVector3& 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 GxVector3 GxVector3::getCrossVector(const GxVector3& vector)
{
    GxVector3 temporary(vector._z, -vector._x, vector._y);
    if(GxVector3::getDot(vector, temporary) <= -1.0f + FLT_EPSILON)
    {
        // 真逆
        temporary._x = -temporary._x;
    }
 
    GxVector3 result;
    GxVector3::getCross(result, vector, temporary);
 
    return result.normalizeEx();
}
 
//---------------------------------------------------------------------------
// 直交する単位ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getCrossVector(GxVector3& dst, const GxVector3& vector)
{
    GxVector3 temporary(vector._z, -vector._x, vector._y);
    if(GxVector3::getDot(vector, temporary) <= -1.0f + FLT_EPSILON)
    {
        // 真逆
        temporary._x = -temporary._x;
    }
 
    GxVector3::getCross(dst, vector, temporary);
 
    return dst.normalizeEx();
}
 
//---------------------------------------------------------------------------
// 距離を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getDistance(const GxVector3& vector0, const GxVector3& vector1)
{
    return GxMath::getSqrt(getDistanceSquare(vector0, vector1));
}
 
//---------------------------------------------------------------------------
// 距離の2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getDistanceSquare(const GxVector3& vector0, const GxVector3& 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 f32 GxVector3::getAngle(const GxVector3& vector0, const GxVector3& vector1)
{
    const auto denominator = vector0.getLengthSquare() * vector1.getLengthSquare();
 
    if( denominator <= FLT_EPSILON )
    {
        return 0.0f;
    }
 
    const auto value = GxMath::getClamp(getDot(vector0, vector1) / GxMath::getSqrt(denominator), -1.0f, 1.0f);
    return GxMath::getACos(value);
}
 
//---------------------------------------------------------------------------
// 角度差を取得(符号つき radian)
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector3::getAngle(const GxVector3& vector0, const GxVector3& vector1, const GxVector3& up)
{
    const auto denominator = vector0.getLengthSquare() * vector1.getLengthSquare();
 
    if( denominator <= FLT_EPSILON )
    {
        return 0.0f;
    }
 
    const auto value = GxMath::getClamp(getDot(vector0, vector1) / GxMath::getSqrt(denominator), -1.0f, 1.0f);
 
    GxVector3 vector2;
    const auto signe = getDot(up, getCross(vector2, vector0, vector1));
    
    return (0.0f <= signe) ? GxMath::getACos(value) : -GxMath::getACos(value);
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getMinimum(const GxVector3& vector0, const GxVector3& vector1)
{
    return GxVector3(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 GxVector3& GxVector3::getMinimum(GxVector3& dst, const GxVector3& vector0, const GxVector3& 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 GxVector3 GxVector3::getMaximum(const GxVector3& vector0, const GxVector3& vector1)
{
    return GxVector3(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 GxVector3& GxVector3::getMaximum(GxVector3& dst, const GxVector3& vector0, const GxVector3& 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 GxVector3 GxVector3::getLerp(const GxVector3& vector0, const GxVector3& vector1, f32 t)
{
    return GxVector3(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 GxVector3& GxVector3::getLerp(GxVector3& dst, const GxVector3& vector0, const GxVector3& vector1, f32 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 f32 GxVector3::getLineParam(const GxVector3& checkPosition, const GxVector3& startPosition, const GxVector3& endPosition)
{
    GxVector3 v0(endPosition - startPosition);
    GxVector3 v1(checkPosition - startPosition);
    auto numerator = GxVector3::getDot(v0, v1);
    auto denominator = GxVector3::getDot(v0, v0);
 
    // 線分の長さが無いときは 0
    if( denominator <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE )
    {
        return 0.0f;
    }
 
    return numerator / denominator;
}
 
//---------------------------------------------------------------------------
//  指定した点を直線上に下ろした点を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getLinePosition(GxVector3& dst, const GxVector3& position, const GxVector3& linePosition0, const GxVector3& linePosition1)
{
    auto t = getLineParam(position, linePosition0, linePosition1);
 
    return GxVector3::getLerp(dst, linePosition0, linePosition1, t);
}
 
//---------------------------------------------------------------------------
// 指定した点を直線上に下ろした点を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getLinePosition(const GxVector3& position, const GxVector3& linePosition0, const GxVector3& linePosition1)
{
    auto t = getLineParam(position, linePosition0, linePosition1);
 
    return GxVector3::getLerp(linePosition0, linePosition1, t);
}
 
//---------------------------------------------------------------------------
//  指定した点を線分上に下ろした点を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::getSegmentPosition(GxVector3& dst, const GxVector3& position, const GxVector3& startPosition, const GxVector3& endPosition)
{
    auto t = getLineParam(position, startPosition, endPosition);
    t = GxMath::getClamp(t, 0.0f, 1.0f);
 
    return GxVector3::getLerp(dst, startPosition, endPosition, t);
}
 
//---------------------------------------------------------------------------
// 指定した点を線分上に下ろした点を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxVector3::getSegmentPosition(const GxVector3& position, const GxVector3& startPosition, const GxVector3& endPosition)
{
    auto t = getLineParam(position, startPosition, endPosition);
    t = GxMath::getClamp(t, 0.0f, 1.0f);
 
    return GxVector3::getLerp(startPosition, endPosition, t);
}
 
//---------------------------------------------------------------------------
// ベクトルが同じ方向を向いているか（ラジアン指定／指定値以内なら(==も含む)同じ方向）
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector3::isSameDirectionLessEqual( const GxVector3& vector0, const GxVector3& vector1, f32 limitRadian )
{
    const auto dot = GxVector3::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 GxVector3::isSameDirectionLessThan( const GxVector3& vector0, const GxVector3& vector1, f32 limitRadian )
{
    const auto dot = GxVector3::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 GxVector3& GxVector3::addScalar(f32 scalar)
{
    _x += scalar;
    _y += scalar;
    _z += scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::subScalar(f32 scalar)
{
    _x -= scalar;
    _y -= scalar;
    _z -= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::mulScalar(f32 scalar)
{
    _x *= scalar;
    _y *= scalar;
    _z *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::divScalar(f32 scalar)
{
    auto inverseScalar = 1.0f / scalar;
 
    _x *= inverseScalar;
    _y *= inverseScalar;
    _z *= inverseScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::addVector(const GxVector3& vector)
{
    _x += vector._x;
    _y += vector._y;
    _z += vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::subVector(const GxVector3& vector)
{
    _x -= vector._x;
    _y -= vector._y;
    _z -= vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::mulVector(const GxVector3& vector)
{
    _x *= vector._x;
    _y *= vector._y;
    _z *= vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::divVector(const GxVector3& vector)
{
    _x /= vector._x;
    _y /= vector._y;
    _z /= vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / length;
 
    _x *= inverseLength;
    _y *= inverseLength;
    _z *= inverseLength;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::normalizeEx(void)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const f32 inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
 
        _x *= inverseLength;
        _y *= inverseLength;
        _z *= inverseLength;
    }
    else
    {
        _x = 0.0f;
        _y = 0.0f;
        _z = 0.0f;
    }
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 座標変換する(w=1.0)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::transform(const GxMatrix44& matrix)
{
    const auto x = _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0];
    const auto y = _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1];
    const auto z = _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2];
 
    _x = x;
    _y = y;
    _z = z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 座標変換する(w=1.0)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::transform(const GxMatrixAffine& matrix)
{
    const auto x = _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0];
    const auto y = _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1];
    const auto z = _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2];
 
    _x = x;
    _y = y;
    _z = z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 座標変換する(w=0.0)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::transformNormal(const GxMatrix44& matrix)
{
    const auto x = _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0];
    const auto y = _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1];
    const auto z = _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2];
 
    _x = x;
    _y = y;
    _z = z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 座標変換する(w=0.0)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::transformNormal(const GxMatrixAffine& matrix)
{
    const auto x = _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0];
    const auto y = _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1];
    const auto z = _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2];
 
    _x = x;
    _y = y;
    _z = z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 座標変換後wで除算する(w=1.0)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::transformCoord(const GxMatrix44& matrix)
{
    const auto x = _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + matrix._m[3][0];
    const auto y = _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + matrix._m[3][1];
    const auto z = _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + matrix._m[3][2];
    const auto inverseW = 1.0f / (_x * matrix._m[0][3] + _y * matrix._m[1][3] + _z * matrix._m[2][3] + matrix._m[3][3]);
 
    _x = x * inverseW;
    _y = y * inverseW;
    _z = z * inverseW;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 回転する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector3& GxVector3::rotate(const GxQuaternion& quaternion)
{
    GxQuaternion q(*this, 0.0f);
    q = quaternion * q * quaternion.getConjugate();
 
    _x = q._x;
    _y = q._y;
    _z = q._z;
 
    return *this;
}
 
//===========================================================================
// GxVector4
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4::GxVector4(f32 x, f32 y, f32 z, f32 w)
: _x(x)
, _y(y)
, _z(z)
, _w(w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4::GxVector4(const GxFloat4& float4)
: _x(float4._x)
, _y(float4._y)
, _z(float4._z)
, _w(float4._w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4::GxVector4(const f32* pFloatArray)
: _x(pFloatArray[0])
, _y(pFloatArray[1])
, _z(pFloatArray[2])
, _w(pFloatArray[3])
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4::GxVector4(const GxVector3& vector, f32 w)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
, _w(w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4::GxVector4(const GxColorHDR& color)
: _x(color._red)
, _y(color._green)
, _z(color._blue)
, _w(color._alpha)
{
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4::GxVector4(const GxVector4& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
, _w(vector._w)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator = (const GxVector3& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator = (const GxVector4& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    _w = vector._w;
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator += (f32 scalar)
{
    addScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator -= (f32 scalar)
{
    subScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator *= (f32 scalar)
{
    mulScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator /= (f32 scalar)
{
    divScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator += (const GxVector4& vector)
{
    addVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator -= (const GxVector4& vector)
{
    subVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator *= (const GxVector4& vector)
{
    mulVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4& GxVector4::operator /= (const GxVector4& vector)
{
    divVector(vector);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator + (const GxVector4& vector, f32 scalar)
{
    GxVector4 result;
    return GxVector4::getAddScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator - (const GxVector4& vector, f32 scalar)
{
    GxVector4 result;
    return GxVector4::getSubScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator * (const GxVector4& vector, f32 scalar)
{
    GxVector4 result;
    return GxVector4::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator * (f32 scalar, const GxVector4& vector)
{
    GxVector4 result;
    return GxVector4::getMulScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator / (const GxVector4& vector, f32 scalar)
{
    GxVector4 result;
    return GxVector4::getDivScalar(result, vector, scalar);
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator + (const GxVector4& vector0, const GxVector4& vector1)
{
    GxVector4 result;
    return GxVector4::getAddVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator - (const GxVector4& vector0, const GxVector4& vector1)
{
    GxVector4 result;
    return GxVector4::getSubVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator * (const GxVector4& vector0, const GxVector4& vector1)
{
    GxVector4 result;
    return GxVector4::getMulVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 operator / (const GxVector4& vector0, const GxVector4& vector1)
{
    GxVector4 result;
    return GxVector4::getDivVector(result, vector0, vector1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxVector4& vector0, const GxVector4& vector1)
{
    return (vector0._x == vector1._x) && (vector0._y == vector1._y) && (vector0._z == vector1._z) && (vector0._w == vector1._w);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxVector4& vector0, const GxVector4& vector1)
{
    return (vector0._x != vector1._x) || (vector0._y != vector1._y) || (vector0._z != vector1._z) || (vector0._w != vector1._w);
}
 
//---------------------------------------------------------------------------
// const配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE const f32& GxVector4::operator[](u32 i) const
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// 配列
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32& GxVector4::operator[](u32 i)
{
    return (&_x)[i];
}
 
//---------------------------------------------------------------------------
// ゼロベクトル判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxVector4::isZeroVector(void) const
{
    return (getLengthSquare() <= GX_VECTOR_ZERO_VECTOR_CHECK_VALUE);
}
 
//---------------------------------------------------------------------------
// 長さを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector4::getLength(void) const
{
    return GxMath::getSqrt(getLengthSquare());
}
 
//---------------------------------------------------------------------------
// 長さの2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector4::getLengthSquare(void) const
{
    return _x * _x + _y * _y + _z * _z + _w * _w;
}
 
//---------------------------------------------------------------------------
// 長さを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxVector4::setLength(f32 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.0f;
    }
#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.0f;
    }
#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 GxVector4::setLengthEx(f32 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.0f;
        _y = 0.0f;
        _z = 0.0f;
        _w = 0.0f;
    }
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4 GxVector4::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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / length;
 
    return GxVector4(_x * inverseLength, _y * inverseLength, _z * inverseLength, _w * inverseLength);
}
 
//---------------------------------------------------------------------------
// 正規化ベクトルを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4 GxVector4::getNormalizeEx(void) const
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
        return GxVector4(_x * inverseLength, _y * inverseLength, _z * inverseLength, _w * inverseLength);
    }
    return GxVector4::ZERO;
}
 
//---------------------------------------------------------------------------
// 座標変換後のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4 GxVector4::getTransform(const GxMatrix44& matrix) const
{
    return GxVector4(
        _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + _w * matrix._m[3][0],
        _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + _w * matrix._m[3][1],
        _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + _w * matrix._m[3][2],
        _x * matrix._m[0][3] + _y * matrix._m[1][3] + _z * matrix._m[2][3] + _w * matrix._m[3][3]);
}
 
//---------------------------------------------------------------------------
// スカラ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::getAddScalar(GxVector4& dst, const GxVector4& vector, f32 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 GxVector4& GxVector4::getSubScalar(GxVector4& dst, const GxVector4& vector, f32 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 GxVector4& GxVector4::getMulScalar(GxVector4& dst, const GxVector4& vector, f32 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 GxVector4& GxVector4::getDivScalar(GxVector4& dst, const GxVector4& vector, f32 scalar)
{
    auto inverseScalar = 1.0f / 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 GxVector4& GxVector4::getAddVector(GxVector4& dst, const GxVector4& vector0, const GxVector4& 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 GxVector4& GxVector4::getSubVector(GxVector4& dst, const GxVector4& vector0, const GxVector4& 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 GxVector4& GxVector4::getMulVector(GxVector4& dst, const GxVector4& vector0, const GxVector4& 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 GxVector4& GxVector4::getDivVector(GxVector4& dst, const GxVector4& vector0, const GxVector4& 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 GxVector4& GxVector4::getNormalize(GxVector4& dst, const GxVector4& 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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / 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 GxVector4& GxVector4::getNormalizeEx(GxVector4& dst, const GxVector4& vector)
{
    const auto lengthSquare = vector.getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0f / 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.0f;
        dst._y = 0.0f;
        dst._z = 0.0f;
        dst._w = 0.0f;
    }
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 座標変換後のベクトルを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::getTransform(GxVector4& dst, const GxVector4& vector, const GxMatrix44& matrix)
{
    dst._x = vector._x * matrix._m[0][0] + vector._y * matrix._m[1][0] + vector._z * matrix._m[2][0] + vector._w * matrix._m[3][0];
    dst._y = vector._x * matrix._m[0][1] + vector._y * matrix._m[1][1] + vector._z * matrix._m[2][1] + vector._w * matrix._m[3][1];
    dst._z = vector._x * matrix._m[0][2] + vector._y * matrix._m[1][2] + vector._z * matrix._m[2][2] + vector._w * matrix._m[3][2];
    dst._w = vector._x * matrix._m[0][3] + vector._y * matrix._m[1][3] + vector._z * matrix._m[2][3] + vector._w * matrix._m[3][3];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 内積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxVector4::getDot(const GxVector4& vector0, const GxVector4& vector1)
{
    return vector0._x * vector1._x + vector0._y * vector1._y + vector0._z * vector1._z + vector0._w * vector1._w;
}
 
//---------------------------------------------------------------------------
// 要素毎に最小値を選択
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector4 GxVector4::getMinimum(const GxVector4& vector0, const GxVector4& vector1)
{
    return GxVector4(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 GxVector4& GxVector4::getMinimum(GxVector4& dst, const GxVector4& vector0, const GxVector4& 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 GxVector4 GxVector4::getMaximum(const GxVector4& vector0, const GxVector4& vector1)
{
    return GxVector4(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 GxVector4& GxVector4::getMaximum(GxVector4& dst, const GxVector4& vector0, const GxVector4& 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 GxVector4 GxVector4::getLerp(const GxVector4& vector0, const GxVector4& vector1, f32 t)
{
    return GxVector4(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 GxVector4& GxVector4::getLerp(GxVector4& dst, const GxVector4& vector0, const GxVector4& vector1, f32 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 GxVector4& GxVector4::addScalar(f32 scalar)
{
    _x += scalar;
    _y += scalar;
    _z += scalar;
    _w += scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::subScalar(f32 scalar)
{
    _x -= scalar;
    _y -= scalar;
    _z -= scalar;
    _w -= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::mulScalar(f32 scalar)
{
    _x *= scalar;
    _y *= scalar;
    _z *= scalar;
    _w *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::divScalar(f32 scalar)
{
    auto inverseScalar = 1.0f / scalar;
 
    _x *= inverseScalar;
    _y *= inverseScalar;
    _z *= inverseScalar;
    _w *= inverseScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::addVector(const GxVector4& vector)
{
    _x += vector._x;
    _y += vector._y;
    _z += vector._z;
    _w += vector._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::subVector(const GxVector4& vector)
{
    _x -= vector._x;
    _y -= vector._y;
    _z -= vector._z;
    _w -= vector._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::mulVector(const GxVector4& vector)
{
    _x *= vector._x;
    _y *= vector._y;
    _z *= vector._z;
    _w *= vector._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// ベクトル除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::divVector(const GxVector4& vector)
{
    _x /= vector._x;
    _y /= vector._y;
    _z /= vector._z;
    _w /= vector._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::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.0f;
    }
#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.0f;
    }
#endif // !GX_VECTOR_ZERO_DIVIDE_WARNING_ENABLE
 
    const auto inverseLength = 1.0f / length;
    _x *= inverseLength;
    _y *= inverseLength;
    _z *= inverseLength;
    _w *= inverseLength;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::normalizeEx(void)
{
    const auto lengthSquare = getLengthSquare();
 
    if( GX_VECTOR_ZERO_VECTOR_CHECK_VALUE < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
        _x *= inverseLength;
        _y *= inverseLength;
        _z *= inverseLength;
        _w *= inverseLength;
    }
    else
    {
        _x = 0.0f;
        _y = 0.0f;
        _z = 0.0f;
        _w = 0.0f;
    }
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 座標変換する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxVector4& GxVector4::transform(const GxMatrix44& matrix)
{
    const auto x = _x * matrix._m[0][0] + _y * matrix._m[1][0] + _z * matrix._m[2][0] + _w * matrix._m[3][0];
    const auto y = _x * matrix._m[0][1] + _y * matrix._m[1][1] + _z * matrix._m[2][1] + _w * matrix._m[3][1];
    const auto z = _x * matrix._m[0][2] + _y * matrix._m[1][2] + _z * matrix._m[2][2] + _w * matrix._m[3][2];
    const auto w = _x * matrix._m[0][3] + _y * matrix._m[1][3] + _z * matrix._m[2][3] + _w * matrix._m[3][3];
 
    _x = x;
    _y = y;
    _z = z;
    _w = w;
 
    return *this;
}
 
#undef GX_VECTOR_ZERO_VECTOR_CHECK_VALUE
 
GX_CORE_NAMESPACE_END()