GxQuaternion.inl

Go to the documentation of this file.

//===========================================================================
//===========================================================================
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
// GxQuaternion
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion::GxQuaternion(f32 x, f32 y, f32 z, f32 w)
    : _x(x)
    , _y(y)
    , _z(z)
    , _w(w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion::GxQuaternion(const GxFloat4& float4)
    : _x(float4._x)
    , _y(float4._y)
    , _z(float4._z)
    , _w(float4._w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion::GxQuaternion(const f32* pFloatArray)
    : _x(pFloatArray[0])
    , _y(pFloatArray[1])
    , _z(pFloatArray[2])
    , _w(pFloatArray[3])
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion::GxQuaternion(const GxVector3& vector, f32 w)
    : _x(vector._x)
    , _y(vector._y)
    , _z(vector._z)
    , _w(w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion::GxQuaternion(const GxVector4& vector)
    : _x(vector._x)
    , _y(vector._y)
    , _z(vector._z)
    , _w(vector._w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion::GxQuaternion(const GxMatrixAffine& matrix)
{
    setRotate(matrix);
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion::GxQuaternion(const GxMatrix44& matrix)
{
    setRotate(matrix);
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion::GxQuaternion(const GxQuaternion& quaternion)
    : _x(quaternion._x)
    , _y(quaternion._y)
    , _z(quaternion._z)
    , _w(quaternion._w)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion& GxQuaternion::operator = (const GxQuaternion& quaternion)
{
    _x = quaternion._x;
    _y = quaternion._y;
    _z = quaternion._z;
    _w = quaternion._w;
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion& GxQuaternion::operator += (f32 scalar)
{
    addScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion& GxQuaternion::operator -= (f32 scalar)
{
    subScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion& GxQuaternion::operator *= (f32 scalar)
{
    mulScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion& GxQuaternion::operator /= (f32 scalar)
{
    divScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオン加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion& GxQuaternion::operator += (const GxQuaternion& quaternion)
{
    addQuaternion(quaternion);
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオン減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion& GxQuaternion::operator -= (const GxQuaternion& quaternion)
{
    subQuaternion(quaternion);
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオン乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion& GxQuaternion::operator *= (const GxQuaternion& quaternion)
{
    mulQuaternion(quaternion);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion operator + (const GxQuaternion& quaternion, f32 scalar)
{
    GxQuaternion result;
    return GxQuaternion::getAddScalar(result, quaternion, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion operator - (const GxQuaternion& quaternion, f32 scalar)
{
    GxQuaternion result;
    return GxQuaternion::getSubScalar(result, quaternion, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion operator * (const GxQuaternion& quaternion, f32 scalar)
{
    GxQuaternion result;
    return GxQuaternion::getMulScalar(result, quaternion, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion operator * (f32 scalar, const GxQuaternion& quaternion)
{
    GxQuaternion result;
    return GxQuaternion::getMulScalar(result, quaternion, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion operator / (const GxQuaternion& quaternion, f32 scalar)
{
    GxQuaternion result;
    return GxQuaternion::getDivScalar(result, quaternion, scalar);
}
 
//---------------------------------------------------------------------------
// クォータニオン加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion operator + (const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    GxQuaternion result;
    return GxQuaternion::getAddQuaternion(result, quaternion0, quaternion1);
}
 
//---------------------------------------------------------------------------
// クォータニオン減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion operator - (const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    GxQuaternion result;
    return GxQuaternion::getSubQuaternion(result, quaternion0, quaternion1);
}
 
//---------------------------------------------------------------------------
// クォータニオン乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion operator * (const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    GxQuaternion result;
    return GxQuaternion::getMulQuaternion(result, quaternion0, quaternion1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    return (quaternion0._x == quaternion1._x) && (quaternion0._y == quaternion1._y) && (quaternion0._z == quaternion1._z) && (quaternion0._w == quaternion1._w);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    return (quaternion0._x != quaternion1._x) || (quaternion0._y != quaternion1._y) || (quaternion0._z != quaternion1._z) || (quaternion0._w != quaternion1._w);
}
 
//---------------------------------------------------------------------------
// 長さを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxQuaternion::getLength(void) const
{
    return GxMath::getSqrt(getLengthSquare());
}
 
//---------------------------------------------------------------------------
// 長さの2乗を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxQuaternion::getLengthSquare(void) const
{
    return _x * _x + _y * _y + _z * _z + _w * _w;
}
 
//---------------------------------------------------------------------------
// 正規化クォータニオンを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion GxQuaternion::getNormalize(void) const
{
    const auto inverseLength = 1.0f / getLength();
 
    return GxQuaternion(
        _x * inverseLength,
        _y * inverseLength,
        _z * inverseLength,
        _w * inverseLength);
}
 
//---------------------------------------------------------------------------
// 正規化クォータニオンを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion GxQuaternion::getNormalizeEx(void) const
{
    const auto lengthSquare = getLengthSquare();
 
    if( F32_ABS_MIN < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
 
        return GxQuaternion(
            _x * inverseLength,
            _y * inverseLength,
            _z * inverseLength,
            _w * inverseLength);
    }
    else
    {
        return GxQuaternion(
            0.0f,
            0.0f,
            0.0f,
            0.0f);
    }
}
 
//---------------------------------------------------------------------------
// 共役クォータニオンを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion GxQuaternion::getConjugate(void) const
{
    return GxQuaternion(-_x, -_y, -_z, _w);
}
 
//---------------------------------------------------------------------------
// 逆クォータニオンを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxQuaternion GxQuaternion::getInverse(void) const
{
    auto lengthSquare = getLengthSquare();
    if(lengthSquare <= F32_ABS_MIN )
    {
        return GxQuaternion::ZERO;
    }
 
    auto inverseLengthSquare = 1.0f / lengthSquare;
 
    return GxQuaternion(-_x * inverseLengthSquare, -_y * inverseLengthSquare, -_z * inverseLengthSquare, _w * inverseLengthSquare);
}
 
//---------------------------------------------------------------------------
// ベクトルから回転を設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxQuaternion::setRotate(const GxVector3& vector)
{
    setRotate(vector._y, vector._x, vector._z);
}
 
//---------------------------------------------------------------------------
// X軸回転を設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxQuaternion::setRotateX(f32 radian)
{
    radian *= 0.5f;
    _x = GxMath::getSin(radian);
    _y = 0.0f;
    _z = 0.0f;
    _w = GxMath::getCos(radian);
}
 
//---------------------------------------------------------------------------
// Y軸回転を設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxQuaternion::setRotateY(f32 radian)
{
    radian *= 0.5f;
    _x = 0.0f;
    _y = GxMath::getSin(radian);
    _z = 0.0f;
    _w = GxMath::getCos(radian);
}
 
//---------------------------------------------------------------------------
// Z軸回転を設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxQuaternion::setRotateZ(f32 radian)
{
    radian *= 0.5f;
    _x = 0.0f;
    _y = 0.0f;
    _z = GxMath::getSin(radian);
    _w = GxMath::getCos(radian);
}
 
//---------------------------------------------------------------------------
// スカラ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getAddScalar(GxQuaternion& dst, const GxQuaternion& quaternion, f32 scalar)
{
    dst._x = quaternion._x + scalar;
    dst._y = quaternion._y + scalar;
    dst._z = quaternion._z + scalar;
    dst._w = quaternion._w + scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getSubScalar(GxQuaternion& dst, const GxQuaternion& quaternion, f32 scalar)
{
    dst._x = quaternion._x - scalar;
    dst._y = quaternion._y - scalar;
    dst._z = quaternion._z - scalar;
    dst._w = quaternion._w - scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulScalar(GxQuaternion& dst, const GxQuaternion& quaternion, f32 scalar)
{
    dst._x = quaternion._x * scalar;
    dst._y = quaternion._y * scalar;
    dst._z = quaternion._z * scalar;
    dst._w = quaternion._w * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getDivScalar(GxQuaternion& dst, const GxQuaternion& quaternion, f32 scalar)
{
    auto inverseScalar = 1.0f / scalar;
 
    dst._x = quaternion._x * inverseScalar;
    dst._y = quaternion._y * inverseScalar;
    dst._z = quaternion._z * inverseScalar;
    dst._w = quaternion._w * inverseScalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// クォータニオン加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getAddQuaternion(GxQuaternion& dst, const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    dst._x = quaternion0._x + quaternion1._x;
    dst._y = quaternion0._y + quaternion1._y;
    dst._z = quaternion0._z + quaternion1._z;
    dst._w = quaternion0._w + quaternion1._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// クォータニオン減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getSubQuaternion(GxQuaternion& dst, const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    dst._x = quaternion0._x - quaternion1._x;
    dst._y = quaternion0._y - quaternion1._y;
    dst._z = quaternion0._z - quaternion1._z;
    dst._w = quaternion0._w - quaternion1._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// クォータニオン乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulQuaternion(GxQuaternion& dst, const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    dst._x = quaternion0._y * quaternion1._z - quaternion0._z * quaternion1._y + quaternion0._w * quaternion1._x + quaternion0._x * quaternion1._w;
    dst._y = quaternion0._z * quaternion1._x - quaternion0._x * quaternion1._z + quaternion0._w * quaternion1._y + quaternion0._y * quaternion1._w;
    dst._z = quaternion0._x * quaternion1._y - quaternion0._y * quaternion1._x + quaternion0._w * quaternion1._z + quaternion0._z * quaternion1._w;
    dst._w = quaternion0._w * quaternion1._w - quaternion0._x * quaternion1._x - quaternion0._y * quaternion1._y - quaternion0._z * quaternion1._z;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化クォータニオンを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getNormalize(GxQuaternion& dst, const GxQuaternion& quaternion)
{
    const auto inverseLength = 1.0f / quaternion.getLength();
 
    dst._x = quaternion._x * inverseLength;
    dst._y = quaternion._y * inverseLength;
    dst._z = quaternion._z * inverseLength;
    dst._w = quaternion._w * inverseLength;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 正規化クォータニオンを取得(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getNormalizeEx(GxQuaternion& dst, const GxQuaternion& quaternion)
{
    const auto lengthSquare = quaternion.getLengthSquare();
 
    if( F32_ABS_MIN < lengthSquare )
    {
        const auto inverseLength = 1.0f / GxMath::getSqrt(lengthSquare);
 
        dst._x = quaternion._x * inverseLength;
        dst._y = quaternion._y * inverseLength;
        dst._z = quaternion._z * inverseLength;
        dst._w = quaternion._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 GxQuaternion& GxQuaternion::getConjugate(GxQuaternion& dst, const GxQuaternion& quaternion)
{
    dst._x = -quaternion._x;
    dst._y = -quaternion._y;
    dst._z = -quaternion._z;
    dst._w =  quaternion._w;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 逆クォータニオンを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getInverse(GxQuaternion& dst, const GxQuaternion& quaternion)
{
    auto lengthSquare = quaternion.getLengthSquare();
    if(lengthSquare <= F32_ABS_MIN )
    {
        dst._x = 0.0f;
        dst._y = 0.0f;
        dst._z = 0.0f;
        dst._w = 0.0f;
    }
    else
    {
        auto inverseLengthSquare = 1.0f / lengthSquare;
        dst._x = -quaternion._x * inverseLengthSquare;
        dst._y = -quaternion._y * inverseLengthSquare;
        dst._z = -quaternion._z * inverseLengthSquare;
        dst._w =  quaternion._w * inverseLengthSquare;
    }
 
    return dst;
}
 
//---------------------------------------------------------------------------
// X軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateX(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radian)
{
    dst = quaternion;
    dst.mulRotateX(radian);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// Y軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateY(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radian)
{
    dst = quaternion;
    dst.mulRotateY(radian);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// Z軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateZ(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radian)
{
    dst = quaternion;
    dst.mulRotateZ(radian);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// XYZ軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateXYZ(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radianX, f32 radianY, f32 radianZ)
{
    dst = quaternion;
    dst.mulRotateXYZ(radianX, radianY, radianZ);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// XZY軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateXZY(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radianX, f32 radianY, f32 radianZ)
{
    dst = quaternion;
    dst.mulRotateXZY(radianX, radianY, radianZ);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// YXZ軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateYXZ(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radianX, f32 radianY, f32 radianZ)
{
    dst = quaternion;
    dst.mulRotateYXZ(radianX, radianY, radianZ);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// YZX軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateYZX(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radianX, f32 radianY, f32 radianZ)
{
    dst = quaternion;
    dst.mulRotateYZX(radianX, radianY, radianZ);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ZXY軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateZXY(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radianX, f32 radianY, f32 radianZ)
{
    dst = quaternion;
    dst.mulRotateZXY(radianX, radianY, radianZ);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// ZYX軸回転乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getMulRotateZYX(GxQuaternion& dst, const GxQuaternion& quaternion, f32 radianX, f32 radianY, f32 radianZ)
{
    dst = quaternion;
    dst.mulRotateZYX(radianX, radianY, radianZ);
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 内積を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxQuaternion::getDot(const GxQuaternion& quaternion0, const GxQuaternion& quaternion1)
{
    return quaternion0._x * quaternion1._x + quaternion0._y * quaternion1._y + quaternion0._z * quaternion1._z + quaternion0._w * quaternion1._w;
}
 
//---------------------------------------------------------------------------
// 線形補間を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getLerp(GxQuaternion& dst, const GxQuaternion& quaternion0, const GxQuaternion& quaternion1, f32 t)
{
    dst._x = quaternion0._x + (quaternion1._x - quaternion0._x) * t;
    dst._y = quaternion0._y + (quaternion1._y - quaternion0._y) * t;
    dst._z = quaternion0._z + (quaternion1._z - quaternion0._z) * t;
    dst._w = quaternion0._w + (quaternion1._w - quaternion0._w) * t;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 球面線形補間を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::getSphericalLerp(GxQuaternion& dst, const GxQuaternion& quaternion0, const GxQuaternion& quaternion1, f32 t)
{
    // TODO:
    GxQuaternion quaternion[2] = { quaternion0, quaternion1 };
    auto dot = GxQuaternion::getDot(quaternion[0], quaternion[1]);
    if( dot < 0.0f ) {
        dot = -dot;
        quaternion[0] = quaternion[0] * -1.0f;
    }
 
    if( dot >= 1.0f - FLT_EPSILON )
    {
        // ほぼ等しい
        return getLerp(dst, quaternion[0], quaternion[1], t);
    }
 
    // 球面線形補間を行う
    const auto angle    = GxMath::getACos(dot);
    const auto rotationInverse = 1.0f / GxMath::getSin(angle);
    const auto rotationFrom = GxMath::getSin(angle * (1.0f - t));
    const auto rotationTo = GxMath::getSin(angle * t);
 
    dst._x = (quaternion[0]._x * rotationFrom + quaternion[1]._x * rotationTo) * rotationInverse;
    dst._y = (quaternion[0]._y * rotationFrom + quaternion[1]._y * rotationTo) * rotationInverse;
    dst._z = (quaternion[0]._z * rotationFrom + quaternion[1]._z * rotationTo) * rotationInverse;
    dst._w = (quaternion[0]._w * rotationFrom + quaternion[1]._w * rotationTo) * rotationInverse;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::addScalar(f32 scalar)
{
    _x += scalar;
    _y += scalar;
    _z += scalar;
    _w += scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::subScalar(f32 scalar)
{
    _x -= scalar;
    _y -= scalar;
    _z -= scalar;
    _w -= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulScalar(f32 scalar)
{
    _x *= scalar;
    _y *= scalar;
    _z *= scalar;
    _w *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::divScalar(f32 scalar)
{
    auto invScalar = 1.0f / scalar;
 
    _x *= invScalar;
    _y *= invScalar;
    _z *= invScalar;
    _w *= invScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオン加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::addQuaternion(const GxQuaternion& quaternion)
{
    _x += quaternion._x;
    _y += quaternion._y;
    _z += quaternion._z;
    _w += quaternion._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオン減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::subQuaternion(const GxQuaternion& quaternion)
{
    _x -= quaternion._x;
    _y -= quaternion._y;
    _z -= quaternion._z;
    _w -= quaternion._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオン乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulQuaternion(const GxQuaternion& quaternion)
{
    const auto x = _y * quaternion._z - _z * quaternion._y + _w * quaternion._x + _x * quaternion._w;
    const auto y = _z * quaternion._x - _x * quaternion._z + _w * quaternion._y + _y * quaternion._w;
    const auto z = _x * quaternion._y - _y * quaternion._x + _w * quaternion._z + _z * quaternion._w;
    const auto w = _w * quaternion._w - _x * quaternion._x - _y * quaternion._y - _z * quaternion._z;
 
    _x = x;
    _y = y;
    _z = z;
    _w = w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::normalize(void)
{
    const auto inverseLength = 1.0f / getLength();
 
    _x *= inverseLength;
    _y *= inverseLength;
    _z *= inverseLength;
    _w *= inverseLength;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 正規化する(長さ0に対応)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::normalizeEx(void)
{
    const auto lengthSquare = getLengthSquare();
 
    if( F32_ABS_MIN < 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 GxQuaternion& GxQuaternion::conjugate(void)
{
    _x = -_x;
    _y = -_y;
    _z = -_z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 逆クォータニオンを計算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::inverse(void)
{
    auto lengthSquare = getLengthSquare();
    if(lengthSquare <= F32_ABS_MIN )
    {
        _x = 0.0f;
        _y = 0.0f;
        _z = 0.0f;
        _w = 0.0f;
    }
    else
    {
        f32 inverseLengthSquare = 1.0f / lengthSquare;
        _x = -_x * inverseLengthSquare;
        _y = -_y * inverseLengthSquare;
        _z = -_z * inverseLengthSquare;
        _w =  _w * inverseLengthSquare;
    }
 
    return *this;
}
 
//---------------------------------------------------------------------------
// X軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateX(f32 radian)
{
    GxQuaternion temporary;
    temporary.setRotateX(radian);
 
    return mulQuaternion(temporary);
}
 
//---------------------------------------------------------------------------
// Y軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateY(f32 radian)
{
    GxQuaternion temporary;
    temporary.setRotateY(radian);
 
    return mulQuaternion(temporary);
}
 
//---------------------------------------------------------------------------
// Z軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateZ(f32 radian)
{
    GxQuaternion temporary;
    temporary.setRotateZ(radian);
 
    return mulQuaternion(temporary);
}
 
//---------------------------------------------------------------------------
// XYZ軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateXYZ(f32 radianX, f32 radianY, f32 radianZ)
{
    GxQuaternion temporary;
    temporary.setRotateXYZ(radianX, radianY, radianZ);
 
    return mulQuaternion(temporary);
}
 
//---------------------------------------------------------------------------
// XZY軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateXZY(f32 radianX, f32 radianY, f32 radianZ)
{
    GxQuaternion temporary;
    temporary.setRotateXZY(radianX, radianY, radianZ);
 
    return mulQuaternion(temporary);
}
 
//---------------------------------------------------------------------------
// YXZ軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateYXZ(f32 radianX, f32 radianY, f32 radianZ)
{
    GxQuaternion temporary;
    temporary.setRotateYXZ(radianX, radianY, radianZ);
 
    return mulQuaternion(temporary);
}
 
//---------------------------------------------------------------------------
// YZX軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateYZX(f32 radianX, f32 radianY, f32 radianZ)
{
    GxQuaternion temporary;
    temporary.setRotateYZX(radianX, radianY, radianZ);
 
    return mulQuaternion(temporary);
}
 
//---------------------------------------------------------------------------
// ZXY軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateZXY(f32 radianX, f32 radianY, f32 radianZ)
{
    GxQuaternion temporary;
    temporary.setRotateZXY(radianX, radianY, radianZ);
 
    return mulQuaternion(temporary);
}
 
//---------------------------------------------------------------------------
// ZYX軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxQuaternion& GxQuaternion::mulRotateZYX(f32 radianX, f32 radianY, f32 radianZ)
{
    GxQuaternion temporary;
    temporary.setRotateZYX(radianX, radianY, radianZ);
 
    return mulQuaternion(temporary);
}
 
GX_CORE_NAMESPACE_END()