GxMatrix.inl

Go to the documentation of this file.

//===========================================================================
//===========================================================================
 
GX_CORE_NAMESPACE_BEGIN()
 
#if defined(GX_USE_SSE2)
#define SPLATX(v) _mm_shuffle_ps(v, v, _MM_SHUFFLE(0,0,0,0))
#define SPLATY(v) _mm_shuffle_ps(v, v, _MM_SHUFFLE(1,1,1,1))
#define SPLATZ(v) _mm_shuffle_ps(v, v, _MM_SHUFFLE(2,2,2,2))
#define SPLATW(v) _mm_shuffle_ps(v, v, _MM_SHUFFLE(3,3,3,3))
 
inline __m128 _mm_rcp_ps_22bit( __m128 a )
{
    __m128 xm0 = a;
    __m128 xm1 = _mm_rcp_ps(xm0);
    xm0 = _mm_mul_ps( _mm_mul_ps( xm0, xm1 ), xm1 );
    xm1 = _mm_add_ps( xm1, xm1 );
    return _mm_sub_ps( xm1, xm0 );
}
#endif //GX_USE_SSE2
//===========================================================================
// GxMatrix22
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix22::GxMatrix22(   f32 m00, f32 m01,
                                    f32 m10, f32 m11)
{
    _m[0][0] = m00;
    _m[0][1] = m01;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix22& GxMatrix22::operator = (const GxMatrix22& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix22& GxMatrix22::operator *= (f32 scalar)
{
    mulScalar(scalar);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix22& GxMatrix22::operator /= (f32 scalar)
{
    divScalar(scalar);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix22& GxMatrix22::operator += (const GxMatrix22& matrix)
{
    addMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix22& GxMatrix22::operator *= (const GxMatrix22& matrix)
{
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22 operator * (const GxMatrix22& matrix, f32 scalar)
{
    GxMatrix22 result; // empty constructor
    return GxMatrix22::getMulScalar(result, matrix, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22 operator / (const GxMatrix22& matrix, f32 scalar)
{
    GxMatrix22 result; // empty constructor
    return GxMatrix22::getDivScalar(result, matrix, scalar);
}
 
//---------------------------------------------------------------------------
// 行列加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22 operator + (const GxMatrix22& matrix0, const GxMatrix22& matrix1)
{
    GxMatrix22 result; // empty constructor
    return GxMatrix22::getAddMatrix(result, matrix0, matrix1);
}
 
//---------------------------------------------------------------------------
// 行列乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22 operator * (const GxMatrix22& matrix0, const GxMatrix22& matrix1)
{
    GxMatrix22 result; // empty constructor
    return GxMatrix22::getMulMatrix(result, matrix0, matrix1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrix22::operator == (const GxMatrix22& matrix)
{
    return ((_m[0][0] == matrix._m[0][0]) && (_m[0][1] == matrix._m[0][1]))
        && ((_m[1][0] == matrix._m[1][0]) && (_m[1][1] == matrix._m[1][1]));
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrix22::operator != (const GxMatrix22& matrix)
{
    return !(*this == matrix);
}
 
//---------------------------------------------------------------------------
// 単位行列に設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix22::setIdentity(void)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 行を取得
//---------------------------------------------------------------------------
const GxVector2& GxMatrix22::getRow(u32 row) const
{
    GX_ASSERT(row < 2, "指定された行数が大きすぎます(%d)", row);
    return *reinterpret_cast<const GxVector2*>(&_m[row][0]);
}
 
//---------------------------------------------------------------------------
// 行を設定
//
//---------------------------------------------------------------------------
void GxMatrix22::setRow(u32 row, const GxVector2& vector)
{
    GX_ASSERT(row < 2, "指定された行数が大きすぎます(%d)", row);
    _m[row][0] = vector._x;
    _m[row][1] = vector._y;
}
 
//---------------------------------------------------------------------------
// 列を取得
//---------------------------------------------------------------------------
GxVector2 GxMatrix22::getColumn(u32 column) const
{
    GX_ASSERT(column < 2, "指定された列数が大きすぎます(%d)", column);
    return GxVector2(_m[0][column], _m[1][column]);
}
 
//---------------------------------------------------------------------------
// 列を設定
//
//---------------------------------------------------------------------------
void GxMatrix22::setColumn(u32 column, const GxVector2& vector)
{
    GX_ASSERT(column < 2, "指定された列数が大きすぎます(%d)", column);
    _m[0][column] = vector._x;
    _m[1][column] = vector._y;
}
 
//---------------------------------------------------------------------------
// 値を取得
//---------------------------------------------------------------------------
f32 GxMatrix22::getValue(u32 row, u32 column) const
{
    GX_ASSERT(row < 2, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 2, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 値を設定
//
//---------------------------------------------------------------------------
void GxMatrix22::setValue(u32 row, u32 column, f32 value)
{
    GX_ASSERT(row < 2, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 2, "指定された列数が大きすぎます(%d)", column);
    _m[row][column] = value;
}
 
//---------------------------------------------------------------------------
// 参照を取得
//---------------------------------------------------------------------------
f32& GxMatrix22::getReference(u32 row, u32 column)
{
    GX_ASSERT(row < 2, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 2, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 参照を取得
//---------------------------------------------------------------------------
const f32& GxMatrix22::getReference(u32 row, u32 column) const
{
    GX_ASSERT(row < 2, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 2, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 行列式の値を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxMatrix22::getDeterminant(void) const
{
    return _m[0][0] * _m[1][1] - _m[1][0] * _m[0][1];
}
 
//---------------------------------------------------------------------------
// 逆行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix22 GxMatrix22::getInverse(void) const
{
    GxMatrix22 result; // empty constructor
    return GxMatrix22::getInverse(result, *this);
}
 
//---------------------------------------------------------------------------
// 転置行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix22 GxMatrix22::getTranspose(void) const
{
    return GxMatrix22(  _m[0][0], _m[1][0],
                        _m[0][1], _m[1][1]);
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::getMulScalar(GxMatrix22& dst, const GxMatrix22& matrix, f32 scalar)
{
    dst._m[0][0] = matrix._m[0][0] * scalar;
    dst._m[0][1] = matrix._m[0][1] * scalar;
 
    dst._m[1][0] = matrix._m[1][0] * scalar;
    dst._m[1][1] = matrix._m[1][1] * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::getDivScalar(GxMatrix22& dst, const GxMatrix22& matrix, f32 scalar)
{
    auto invScalar = 1.0f / scalar;
 
    dst._m[0][0] = matrix._m[0][0] * invScalar;
    dst._m[0][1] = matrix._m[0][1] * invScalar;
 
    dst._m[1][0] = matrix._m[1][0] * invScalar;
    dst._m[1][1] = matrix._m[1][1] * invScalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::getAddMatrix(GxMatrix22& dst, const GxMatrix22& matrix0, const GxMatrix22& matrix1)
{
    dst._m[0][0] = matrix0._m[0][0] + matrix1._m[0][0];
    dst._m[0][1] = matrix0._m[0][1] + matrix1._m[0][1];
 
    dst._m[1][0] = matrix0._m[1][0] + matrix1._m[1][0];
    dst._m[1][1] = matrix0._m[1][1] + matrix1._m[1][1];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::getMulMatrix(GxMatrix22& dst, const GxMatrix22& matrix0, const GxMatrix22& matrix1)
{
    // 入力と出力が同じ行列だった場合を考慮して、一時変数で計算する
    const auto m00 = matrix0._m[0][0] * matrix1._m[0][0] + matrix0._m[0][1] * matrix1._m[1][0];
    const auto m01 = matrix0._m[0][0] * matrix1._m[0][1] + matrix0._m[0][1] * matrix1._m[1][1];
 
    const auto m10 = matrix0._m[1][0] * matrix1._m[0][0] + matrix0._m[1][1] * matrix1._m[1][0];
    const auto m11 = matrix0._m[1][0] * matrix1._m[0][1] + matrix0._m[1][1] * matrix1._m[1][1];
 
    dst._m[0][0] = m00;
    dst._m[0][1] = m01;
 
    dst._m[1][0] = m10;
    dst._m[1][1] = m11;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 逆行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::getInverse(GxMatrix22& dst, const GxMatrix22& matrix)
{
    const auto m00 = matrix._m[1][1];
    const auto m01 =-matrix._m[0][1];
 
    const auto m10 =-matrix._m[1][0];
    const auto m11 = matrix._m[0][0];
 
    const auto d = 1.0f / matrix.getDeterminant();
 
    dst._m[0][0] = m00 * d;
    dst._m[0][1] = m01 * d;
 
    dst._m[1][0] = m10 * d;
    dst._m[1][1] = m11 * d;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 転置行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::getTranspose(GxMatrix22& dst, const GxMatrix22& matrix)
{
    const auto m00 = matrix._m[0][0];
    const auto m01 = matrix._m[1][0];
                    
    const auto m10 = matrix._m[0][1];
    const auto m11 = matrix._m[1][1];
                    
    dst._m[0][0] = m00;
    dst._m[0][1] = m01;
                   
    dst._m[1][0] = m10;
    dst._m[1][1] = m11;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::mulScalar(f32 scalar)
{
    _m[0][0] *= scalar;
    _m[0][1] *= scalar;
 
    _m[1][0] *= scalar;
    _m[1][1] *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::divScalar(f32 scalar)
{
    auto invScalar = 1.0f / scalar;
 
    _m[0][0] *= invScalar;
    _m[0][1] *= invScalar;
 
    _m[1][0] *= invScalar;
    _m[1][1] *= invScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::addMatrix(const GxMatrix22& matrix)
{
    _m[0][0] += matrix._m[0][0];
    _m[0][1] += matrix._m[0][1];
 
    _m[1][0] += matrix._m[1][0];
    _m[1][1] += matrix._m[1][1];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::mulMatrix(const GxMatrix22& matrix)
{
    const auto m00 = _m[0][0] * matrix._m[0][0] + _m[0][1] * matrix._m[1][0];
    const auto m01 = _m[0][0] * matrix._m[0][1] + _m[0][1] * matrix._m[1][1];
 
    const auto m10 = _m[1][0] * matrix._m[0][0] + _m[1][1] * matrix._m[1][0];
    const auto m11 = _m[1][0] * matrix._m[0][1] + _m[1][1] * matrix._m[1][1];
 
    _m[0][0] = m00;
    _m[0][1] = m01;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 逆行列を計算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::inverse(void)
{
    const auto m00 = _m[1][1];
    const auto m01 =-_m[0][1];
 
    const auto m10 =-_m[1][0];
    const auto m11 = _m[0][0];
 
    const auto d = 1.0f / getDeterminant();
 
    _m[0][0] = m00 * d;
    _m[0][1] = m01 * d;
 
    _m[1][0] = m10 * d;
    _m[1][1] = m11 * d;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 転置する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix22& GxMatrix22::transpose(void)
{
    const auto m00 = _m[0][0];
    const auto m01 = _m[1][0];
                    
    const auto m10 = _m[0][1];
    const auto m11 = _m[1][1];
                    
    _m[0][0] = m00;
    _m[0][1] = m01;
               
    _m[1][0] = m10;
    _m[1][1] = m11;
               
    return *this;
}
 
//===========================================================================
// GxMatrix33
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix33::GxMatrix33(   f32 m00, f32 m01, f32 m02,
                                    f32 m10, f32 m11, f32 m12,
                                    f32 m20, f32 m21, f32 m22)
{
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
 
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix33& GxMatrix33::operator = (const GxMatrix33& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix33& GxMatrix33::operator *= (f32 scalar)
{
    mulScalar(scalar);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix33& GxMatrix33::operator /= (f32 scalar)
{
    divScalar(scalar);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix33& GxMatrix33::operator += (const GxMatrix33& matrix)
{
    addMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix33& GxMatrix33::operator *= (const GxMatrix33& matrix)
{
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33 operator * (const GxMatrix33& matrix, f32 scalar)
{
    GxMatrix33 result; // empty constructor
    GxMatrix33::getMulScalar(result, matrix, scalar);
 
    return result;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33 operator / (const GxMatrix33& matrix, f32 scalar)
{
    GxMatrix33 result; // empty constructor
    GxMatrix33::getDivScalar(result, matrix, scalar);
 
    return result;
}
 
//---------------------------------------------------------------------------
// 行列加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33 operator + (const GxMatrix33& matrix0, const GxMatrix33& matrix1)
{
    GxMatrix33 result; // empty constructor
    GxMatrix33::getAddMatrix(result, matrix0, matrix1);
 
    return result;
}
 
//---------------------------------------------------------------------------
// 行列乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33 operator * (const GxMatrix33& matrix0, const GxMatrix33& matrix1)
{
    GxMatrix33 result; // empty constructor
    GxMatrix33::getMulMatrix(result, matrix0, matrix1);
 
    return result;
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrix33::operator == (const GxMatrix33& matrix)
{
    return ((_m[0][0] == matrix._m[0][0]) && (_m[0][1] == matrix._m[0][1]) && (_m[0][2] == matrix._m[0][2]))
        && ((_m[1][0] == matrix._m[1][0]) && (_m[1][1] == matrix._m[1][1]) && (_m[1][2] == matrix._m[1][2]))
        && ((_m[2][0] == matrix._m[2][0]) && (_m[2][1] == matrix._m[2][1]) && (_m[2][2] == matrix._m[2][2]));
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrix33::operator != (const GxMatrix33& matrix)
{
    return !(*this == matrix);
}
 
//---------------------------------------------------------------------------
// 単位行列に設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix33::setIdentity(void)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix33::setRotate(f32 sinValue, f32 cosValue)
{
    _m[0][0] = cosValue;
    _m[0][1] = sinValue;
    _m[0][2] = 0.0f;
 
    _m[1][0] =-sinValue;
    _m[1][1] = cosValue;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 平行移動行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix33::setTranslate(const GxVector2& vector)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
 
    _m[2][0] = vector._x;
    _m[2][1] = vector._y;
    _m[2][2] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 平行移動行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix33::setTranslate(f32 x, f32 y)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
 
    _m[2][0] = x;
    _m[2][1] = y;
    _m[2][2] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 平行移動量のみを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix33::setPosition(const GxVector2& position)
{
    _m[2][0] = position._x;
    _m[2][1] = position._y;
}
 
//---------------------------------------------------------------------------
// 平行移動量のみを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix33::setPosition(f32 x, f32 y)
{
    _m[2][0] = x;
    _m[2][1] = y;
}
 
//---------------------------------------------------------------------------
// スケール行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix33::setScale(const GxVector2& vector)
{
    _m[0][0] = vector._x;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = vector._y;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
}
 
//---------------------------------------------------------------------------
// スケール行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix33::setScale(f32 x, f32 y)
{
    _m[0][0] = x;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = y;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 行を取得
//---------------------------------------------------------------------------
const GxVector3& GxMatrix33::getRow(u32 row) const
{
    GX_ASSERT(row < 3, "指定された行数が大きすぎます(%d)", row);
    return *reinterpret_cast<const GxVector3*>(&_m[row][0]);
}
 
//---------------------------------------------------------------------------
// 行を設定
//---------------------------------------------------------------------------
void GxMatrix33::setRow(u32 row, const GxVector3& vector)
{
    GX_ASSERT(row < 3, "指定された行数が大きすぎます(%d)", row);
    _m[row][0] = vector._x;
    _m[row][1] = vector._y;
    _m[row][2] = vector._z;
}
 
//---------------------------------------------------------------------------
// 列を取得
//---------------------------------------------------------------------------
GxVector3 GxMatrix33::getColumn(u32 column) const
{
    GX_ASSERT(column < 3, "指定された列数が大きすぎます(%d)", column);
    return GxVector3(_m[0][column], _m[1][column], _m[2][column]);
}
 
//---------------------------------------------------------------------------
// 列を設定
//---------------------------------------------------------------------------
void GxMatrix33::setColumn(u32 column, const GxVector3& vector)
{
    GX_ASSERT(column < 3, "指定された列数が大きすぎます(%d)", column);
    _m[0][column] = vector._x;
    _m[1][column] = vector._y;
    _m[2][column] = vector._z;
}
 
//---------------------------------------------------------------------------
// 値を取得
//---------------------------------------------------------------------------
f32 GxMatrix33::getValue(u32 row, u32 column) const
{
    GX_ASSERT(row < 3, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 3, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 値を設定
//
//---------------------------------------------------------------------------
void GxMatrix33::setValue(u32 row, u32 column, f32 value)
{
    GX_ASSERT(row < 3, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 3, "指定された列数が大きすぎます(%d)", column);
    _m[row][column] = value;
}
 
//---------------------------------------------------------------------------
// 参照を取得
//---------------------------------------------------------------------------
f32& GxMatrix33::getReference(u32 row, u32 column)
{
    GX_ASSERT(row < 3, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 3, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 参照を取得
//---------------------------------------------------------------------------
const f32& GxMatrix33::getReference(u32 row, u32 column) const
{
    GX_ASSERT(row < 3, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 3, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 行列式の値を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxMatrix33::getDeterminant(void) const
{
    return _m[0][0] * (_m[1][1] * _m[2][2] - _m[2][1] * _m[1][2])
         - _m[0][1] * (_m[1][0] * _m[2][2] - _m[2][0] * _m[1][2])
         + _m[0][2] * (_m[1][0] * _m[2][1] - _m[2][0] * _m[1][1]);
}
 
//---------------------------------------------------------------------------
// 逆行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix33 GxMatrix33::getInverse(void) const
{
    GxMatrix33 result; // empty constructor
    return GxMatrix33::getInverse(result, *this);
}
 
//---------------------------------------------------------------------------
// 転置行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix33 GxMatrix33::getTranspose(void) const
{
    return GxMatrix33(  _m[0][0], _m[1][0], _m[2][0],
                        _m[0][1], _m[1][1], _m[2][1],
                        _m[0][2], _m[1][2], _m[2][2]);
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::getMulScalar(GxMatrix33& dst, const GxMatrix33& matrix, f32 scalar)
{
    dst._m[0][0] = matrix._m[0][0] * scalar;
    dst._m[0][1] = matrix._m[0][1] * scalar;
    dst._m[0][2] = matrix._m[0][2] * scalar;
 
    dst._m[1][0] = matrix._m[1][0] * scalar;
    dst._m[1][1] = matrix._m[1][1] * scalar;
    dst._m[1][2] = matrix._m[1][2] * scalar;
 
    dst._m[2][0] = matrix._m[2][0] * scalar;
    dst._m[2][1] = matrix._m[2][1] * scalar;
    dst._m[2][2] = matrix._m[2][2] * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::getDivScalar(GxMatrix33& dst, const GxMatrix33& matrix, f32 scalar)
{
    auto invScalar = 1.0f / scalar;
 
    dst._m[0][0] = matrix._m[0][0] * invScalar;
    dst._m[0][1] = matrix._m[0][1] * invScalar;
    dst._m[0][2] = matrix._m[0][2] * invScalar;
 
    dst._m[1][0] = matrix._m[1][0] * invScalar;
    dst._m[1][1] = matrix._m[1][1] * invScalar;
    dst._m[1][2] = matrix._m[1][2] * invScalar;
 
    dst._m[2][0] = matrix._m[2][0] * invScalar;
    dst._m[2][1] = matrix._m[2][1] * invScalar;
    dst._m[2][2] = matrix._m[2][2] * invScalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::getAddMatrix(GxMatrix33& dst, const GxMatrix33& matrix0, const GxMatrix33& matrix1)
{
    dst._m[0][0] = matrix0._m[0][0] + matrix1._m[0][0];
    dst._m[0][1] = matrix0._m[0][1] + matrix1._m[0][1];
    dst._m[0][2] = matrix0._m[0][2] + matrix1._m[0][2];
 
    dst._m[1][0] = matrix0._m[1][0] + matrix1._m[1][0];
    dst._m[1][1] = matrix0._m[1][1] + matrix1._m[1][1];
    dst._m[1][2] = matrix0._m[1][2] + matrix1._m[1][2];
 
    dst._m[2][0] = matrix0._m[2][0] + matrix1._m[2][0];
    dst._m[2][1] = matrix0._m[2][1] + matrix1._m[2][1];
    dst._m[2][2] = matrix0._m[2][2] + matrix1._m[2][2];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::getMulMatrix(GxMatrix33& dst, const GxMatrix33& matrix0, const GxMatrix33& matrix1)
{
    // 入力と出力が同じ行列だった場合を考慮して、一時変数で計算する
    const auto m00 = matrix0._m[0][0] * matrix1._m[0][0] + matrix0._m[0][1] * matrix1._m[1][0] + matrix0._m[0][2] * matrix1._m[2][0];
    const auto m01 = matrix0._m[0][0] * matrix1._m[0][1] + matrix0._m[0][1] * matrix1._m[1][1] + matrix0._m[0][2] * matrix1._m[2][1];
    const auto m02 = matrix0._m[0][0] * matrix1._m[0][2] + matrix0._m[0][1] * matrix1._m[1][2] + matrix0._m[0][2] * matrix1._m[2][2];
 
    const auto m10 = matrix0._m[1][0] * matrix1._m[0][0] + matrix0._m[1][1] * matrix1._m[1][0] + matrix0._m[1][2] * matrix1._m[2][0];
    const auto m11 = matrix0._m[1][0] * matrix1._m[0][1] + matrix0._m[1][1] * matrix1._m[1][1] + matrix0._m[1][2] * matrix1._m[2][1];
    const auto m12 = matrix0._m[1][0] * matrix1._m[0][2] + matrix0._m[1][1] * matrix1._m[1][2] + matrix0._m[1][2] * matrix1._m[2][2];
 
    const auto m20 = matrix0._m[2][0] * matrix1._m[0][0] + matrix0._m[2][1] * matrix1._m[1][0] + matrix0._m[2][2] * matrix1._m[2][0];
    const auto m21 = matrix0._m[2][0] * matrix1._m[0][1] + matrix0._m[2][1] * matrix1._m[1][1] + matrix0._m[2][2] * matrix1._m[2][1];
    const auto m22 = matrix0._m[2][0] * matrix1._m[0][2] + matrix0._m[2][1] * matrix1._m[1][2] + matrix0._m[2][2] * matrix1._m[2][2];
 
    dst._m[0][0] = m00;
    dst._m[0][1] = m01;
    dst._m[0][2] = m02;
 
    dst._m[1][0] = m10;
    dst._m[1][1] = m11;
    dst._m[1][2] = m12;
 
    dst._m[2][0] = m20;
    dst._m[2][1] = m21;
    dst._m[2][2] = m22;
 
    return dst;
}
 
 
//---------------------------------------------------------------------------
// 逆行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::getInverse(GxMatrix33& dst, const GxMatrix33& matrix)
{
    const auto m00 = matrix._m[1][1] * matrix._m[2][2] - matrix._m[1][2] * matrix._m[2][1];
    const auto m01 = matrix._m[1][2] * matrix._m[2][0] - matrix._m[1][0] * matrix._m[2][2];
    const auto m02 = matrix._m[1][0] * matrix._m[2][1] - matrix._m[1][1] * matrix._m[2][0];
 
    const auto m10 = matrix._m[0][2] * matrix._m[2][1] - matrix._m[0][1] * matrix._m[2][2];
    const auto m11 = matrix._m[0][0] * matrix._m[2][2] - matrix._m[0][2] * matrix._m[2][0];
    const auto m12 = matrix._m[0][1] * matrix._m[2][0] - matrix._m[0][0] * matrix._m[2][1];
 
    const auto m20 = matrix._m[0][1] * matrix._m[1][2] - matrix._m[0][2] * matrix._m[1][1];
    const auto m21 = matrix._m[0][2] * matrix._m[1][0] - matrix._m[0][0] * matrix._m[1][2];
    const auto m22 = matrix._m[0][0] * matrix._m[1][1] - matrix._m[0][1] * matrix._m[1][0];
 
    const auto d = 1.0f / matrix.getDeterminant();
 
    dst._m[0][0] = m00 * d;
    dst._m[0][1] = m01 * d;
    dst._m[0][2] = m02 * d;
 
    dst._m[1][0] = m10 * d;
    dst._m[1][1] = m11 * d;
    dst._m[1][2] = m12 * d;
 
    dst._m[2][0] = m20 * d;
    dst._m[2][1] = m21 * d;
    dst._m[2][2] = m22 * d;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 転置行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::getTranspose(GxMatrix33& dst, const GxMatrix33& matrix)
{
    const auto m00 = matrix._m[0][0];
    const auto m01 = matrix._m[1][0];
    const auto m02 = matrix._m[2][0];
                    
    const auto m10 = matrix._m[0][1];
    const auto m11 = matrix._m[1][1];
    const auto m12 = matrix._m[2][1];
                    
    const auto m20 = matrix._m[0][2];
    const auto m21 = matrix._m[1][2];
    const auto m22 = matrix._m[2][2];
 
    dst._m[0][0] = m00;
    dst._m[0][1] = m01;
    dst._m[0][2] = m02;
                   
    dst._m[1][0] = m10;
    dst._m[1][1] = m11;
    dst._m[1][2] = m12;
                   
    dst._m[2][0] = m20;
    dst._m[2][1] = m21;
    dst._m[2][2] = m22;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::mulScalar(f32 scalar)
{
    _m[0][0] *= scalar;
    _m[0][1] *= scalar;
    _m[0][2] *= scalar;
 
    _m[1][0] *= scalar;
    _m[1][1] *= scalar;
    _m[1][2] *= scalar;
 
    _m[2][0] *= scalar;
    _m[2][1] *= scalar;
    _m[2][2] *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::divScalar(f32 scalar)
{
    auto invScalar = 1.0f / scalar;
 
    _m[0][0] *= invScalar;
    _m[0][1] *= invScalar;
    _m[0][2] *= invScalar;
 
    _m[1][0] *= invScalar;
    _m[1][1] *= invScalar;
    _m[1][2] *= invScalar;
 
    _m[2][0] *= invScalar;
    _m[2][1] *= invScalar;
    _m[2][2] *= invScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::addMatrix(const GxMatrix33& matrix)
{
    _m[0][0] += matrix._m[0][0];
    _m[0][1] += matrix._m[0][1];
    _m[0][2] += matrix._m[0][2];
 
    _m[1][0] += matrix._m[1][0];
    _m[1][1] += matrix._m[1][1];
    _m[1][2] += matrix._m[1][2];
 
    _m[2][0] += matrix._m[2][0];
    _m[2][1] += matrix._m[2][1];
    _m[2][2] += matrix._m[2][2];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::mulMatrix(const GxMatrix33& matrix)
{
    const auto m00 = _m[0][0] * matrix._m[0][0] + _m[0][1] * matrix._m[1][0] + _m[0][2] * matrix._m[2][0];
    const auto m01 = _m[0][0] * matrix._m[0][1] + _m[0][1] * matrix._m[1][1] + _m[0][2] * matrix._m[2][1];
    const auto m02 = _m[0][0] * matrix._m[0][2] + _m[0][1] * matrix._m[1][2] + _m[0][2] * matrix._m[2][2];
    
    const auto m10 = _m[1][0] * matrix._m[0][0] + _m[1][1] * matrix._m[1][0] + _m[1][2] * matrix._m[2][0];
    const auto m11 = _m[1][0] * matrix._m[0][1] + _m[1][1] * matrix._m[1][1] + _m[1][2] * matrix._m[2][1];
    const auto m12 = _m[1][0] * matrix._m[0][2] + _m[1][1] * matrix._m[1][2] + _m[1][2] * matrix._m[2][2];
    
    const auto m20 = _m[2][0] * matrix._m[0][0] + _m[2][1] * matrix._m[1][0] + _m[2][2] * matrix._m[2][0];
    const auto m21 = _m[2][0] * matrix._m[0][1] + _m[2][1] * matrix._m[1][1] + _m[2][2] * matrix._m[2][1];
    const auto m22 = _m[2][0] * matrix._m[0][2] + _m[2][1] * matrix._m[1][2] + _m[2][2] * matrix._m[2][2];
    
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
 
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::mulRotate(f32 radian)
{
    GxMatrix33 matrix;
    matrix.setRotate(radian);
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 平行移動乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::mulTranslate(const GxVector2& vector)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix33 matrix;
    matrix.setTranslate(vector);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[2][0] += vector._x;
    _m[2][1] += vector._y;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 平行移動乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::mulTranslate(f32 x, f32 y)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix33 matrix;
    matrix.setTranslate(x, y);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[2][0] += x;
    _m[2][1] += y;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スケール乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::mulScale(const GxVector2& vector)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix33 matrix;
    matrix.setScale(vector);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[0][0] = _m[0][0] * vector._x;
    _m[0][1] = _m[0][1] * vector._y;
    
    _m[1][0] = _m[1][0] * vector._x;
    _m[1][1] = _m[1][1] * vector._y;
    
    _m[2][0] = _m[2][0] * vector._x;
    _m[2][1] = _m[2][1] * vector._y;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スケール乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::mulScale(f32 x, f32 y)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix33 matrix;
    matrix.setScale(x, y);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[0][0] = _m[0][0] * x;
    _m[0][1] = _m[0][1] * y;
    
    _m[1][0] = _m[1][0] * x;
    _m[1][1] = _m[1][1] * y;
    
    _m[2][0] = _m[2][0] * x;
    _m[2][1] = _m[2][1] * y;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 逆行列にする
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::inverse(void)
{
    const auto m00 = _m[1][1] * _m[2][2] - _m[1][2] * _m[2][1];
    const auto m01 = _m[1][2] * _m[2][0] - _m[1][0] * _m[2][2];
    const auto m02 = _m[1][0] * _m[2][1] - _m[1][1] * _m[2][0];
 
    const auto m10 = _m[0][2] * _m[2][1] - _m[0][1] * _m[2][2];
    const auto m11 = _m[0][0] * _m[2][2] - _m[0][2] * _m[2][0];
    const auto m12 = _m[0][1] * _m[2][0] - _m[0][0] * _m[2][1];
 
    const auto m20 = _m[0][1] * _m[1][2] - _m[0][2] * _m[1][1];
    const auto m21 = _m[0][2] * _m[1][0] - _m[0][0] * _m[1][2];
    const auto m22 = _m[0][0] * _m[1][1] - _m[0][1] * _m[1][0];
 
    const auto d = 1.0f / getDeterminant();
 
    _m[0][0] = m00 * d;
    _m[0][1] = m01 * d;
    _m[0][2] = m02 * d;
 
    _m[1][0] = m10 * d;
    _m[1][1] = m11 * d;
    _m[1][2] = m12 * d;
 
    _m[2][0] = m20 * d;
    _m[2][1] = m21 * d;
    _m[2][2] = m22 * d;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 転置する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix33& GxMatrix33::transpose(void)
{
    const auto m00 = _m[0][0];
    const auto m01 = _m[1][0];
    const auto m02 = _m[2][0];
                    
    const auto m10 = _m[0][1];
    const auto m11 = _m[1][1];
    const auto m12 = _m[2][1];
                    
    const auto m20 = _m[0][2];
    const auto m21 = _m[1][2];
    const auto m22 = _m[2][2];
                    
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
               
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
               
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
 
    return *this;
}
 
//===========================================================================
// GxMatrixAffine
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ(引数のタイプで要素を初期化する)
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffine::GxMatrixAffine(INIT initType)
{
    switch(initType)
    {
    case INIT::ZERO:
        setZero();
        break;
    case INIT::IDENTITY:
        setIdentity();
        break;
    case INIT::NONE:
    default:
        break;
    }
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffine::GxMatrixAffine(const GxQuaternion& quaternion, const GxVector3& position)
{
    setRotate(quaternion);
    setPosition(position);
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffine::GxMatrixAffine(const GxQuaternion& quaternion)
{
    setRotate(quaternion);
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffine::GxMatrixAffine(const GxVector3& position)
{
    setTranslate(position);
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffine::GxMatrixAffine(   f32 m00, f32 m01, f32 m02,
                                            f32 m10, f32 m11, f32 m12,
                                            f32 m20, f32 m21, f32 m22,
                                            f32 m30, f32 m31, f32 m32)
{
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
 
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
    
    _m[3][0] = m30;
    _m[3][1] = m31;
    _m[3][2] = m32;
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffine::GxMatrixAffine(const GxMatrix44& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
 
    _m[3][0] = matrix._m[3][0];
    _m[3][1] = matrix._m[3][1];
    _m[3][2] = matrix._m[3][2];
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffine::GxMatrixAffine(const GxVector3& position, const GxMatrix33& orientation)
{
    _m[0][0] = orientation._m[0][0];
    _m[0][1] = orientation._m[0][1];
    _m[0][2] = orientation._m[0][2];
 
    _m[1][0] = orientation._m[1][0];
    _m[1][1] = orientation._m[1][1];
    _m[1][2] = orientation._m[1][2];
 
    _m[2][0] = orientation._m[2][0];
    _m[2][1] = orientation._m[2][1];
    _m[2][2] = orientation._m[2][2];
 
    _m[3][0] = position._x;
    _m[3][1] = position._y;
    _m[3][2] = position._z;
}
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffine::GxMatrixAffine(const GxMatrixAffine& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
 
    _m[3][0] = matrix._m[3][0];
    _m[3][1] = matrix._m[3][1];
    _m[3][2] = matrix._m[3][2];
}
 
//---------------------------------------------------------------------------
// 0を設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setZero(void)
{
#if defined(GX_USE_SSE2)
    _r[0] = _mm_setzero_ps();
    _r[1] = _mm_setzero_ps();
    _r[2] = _mm_setzero_ps();
    _r[3] = _mm_setzero_ps();
#else //GX_USE_SSE2
    for( u32 c = 0; c < 4; c++ )
    {
        _m[c][0] = 0.0f;
        _m[c][1] = 0.0f;
        _m[c][2] = 0.0f;
        _m[c][3] = 0.0f;
    }
#endif // !GX_USE_SSE2
}
 
//---------------------------------------------------------------------------
// 初期化
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::initialize(const GxQuaternion& quaternion, const GxVector3& position)
{
    setRotate(quaternion);
    setPosition(position);
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrixAffine& GxMatrixAffine::operator = (const GxMatrixAffine& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
 
    _m[3][0] = matrix._m[3][0];
    _m[3][1] = matrix._m[3][1];
    _m[3][2] = matrix._m[3][2];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrixAffine& GxMatrixAffine::operator *= (f32 scalar)
{
    mulScalar(scalar);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrixAffine& GxMatrixAffine::operator /= (f32 scalar)
{
    divScalar(scalar);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrixAffine& GxMatrixAffine::operator += (const GxMatrixAffine& matrix)
{
    addMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrixAffine& GxMatrixAffine::operator *= (const GxMatrixAffine& matrix)
{
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine operator * (const GxMatrixAffine& matrix, f32 scalar)
{
    GxMatrixAffine result(INIT::NONE);
    return GxMatrixAffine::getMulScalar(result, matrix, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine operator / (const GxMatrixAffine& matrix, f32 scalar)
{
    GxMatrixAffine result(INIT::NONE);
    return GxMatrixAffine::getDivScalar(result, matrix, scalar);
}
 
//---------------------------------------------------------------------------
// 行列加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine operator + (const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1)
{
    GxMatrixAffine result(INIT::NONE);
    return GxMatrixAffine::getAddMatrix(result, matrix0, matrix1);
}
 
//---------------------------------------------------------------------------
// 行列乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine operator * (const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1)
{
    GxMatrixAffine result(INIT::NONE);
    return GxMatrixAffine::getMulMatrix(result, matrix0, matrix1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrixAffine::operator == (const GxMatrixAffine& matrix)
{
    return ((_m[0][0] == matrix._m[0][0]) && (_m[0][1] == matrix._m[0][1]) && (_m[0][2] == matrix._m[0][2]))
        && ((_m[1][0] == matrix._m[1][0]) && (_m[1][1] == matrix._m[1][1]) && (_m[1][2] == matrix._m[1][2]))
        && ((_m[2][0] == matrix._m[2][0]) && (_m[2][1] == matrix._m[2][1]) && (_m[2][2] == matrix._m[2][2]))
        && ((_m[3][0] == matrix._m[3][0]) && (_m[3][1] == matrix._m[3][1]) && (_m[3][2] == matrix._m[3][2]));
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrixAffine::operator != (const GxMatrixAffine& matrix)
{
    return !(*this == matrix);
}
 
//---------------------------------------------------------------------------
// 単位行列に設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setIdentity(void)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定(X軸回転)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setRotateX(f32 sinValue, f32 cosValue)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = cosValue;
    _m[1][2] = sinValue;
 
    _m[2][0] = 0.0f;
    _m[2][1] =-sinValue;
    _m[2][2] = cosValue;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定(Y軸回転)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setRotateY(f32 sinValue, f32 cosValue)
{
    _m[0][0] = cosValue;
    _m[0][1] = 0.0f;
    _m[0][2] =-sinValue;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
 
    _m[2][0] = sinValue;
    _m[2][1] = 0.0f;
    _m[2][2] = cosValue;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定(Z軸回転)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setRotateZ(f32 sinValue, f32 cosValue)
{
    _m[0][0] = cosValue;
    _m[0][1] = sinValue;
    _m[0][2] = 0.0f;
 
    _m[1][0] =-sinValue;
    _m[1][1] = cosValue;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
}
 
//---------------------------------------------------------------------------
// XYZ軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrixAffine::getRotateXYZ(void) const
{
    // TODO:
    GxVector3   vector;
 
    if( _m[0][2] < 1.0f )
    {
        if( _m[0][2] > -1.0f )
        {
            vector._x = -GxMath::getATan2(-_m[1][2], _m[2][2]);
            vector._y = -GxMath::getASin(_m[0][2]);
            vector._z = -GxMath::getATan2(-_m[0][1], _m[0][0]);
        }
        else
        {
            vector._x = GxMath::getATan2(_m[1][0], _m[1][1]);
            vector._y = PI * 0.5f;
            vector._z = 0.0f;
        }
    }
    else
    {
        vector._x = -GxMath::getATan2(_m[1][0], _m[1][1]);
        vector._y = -PI * 0.5f;
        vector._z = 0.0f;
    }
    return vector;
}
 
//---------------------------------------------------------------------------
// XZY軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrixAffine::getRotateXZY(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[0][1] < 1.0f )
    {
        if( _m[0][1] > -1.0f )
        {
            vector._x = -GxMath::getATan2(_m[2][1], _m[1][1]);
            vector._z = -GxMath::getASin(-_m[0][1]);
            vector._y = -GxMath::getATan2(_m[0][2], _m[0][0]);
        }
        else
        {
            vector._x = -GxMath::getATan2(_m[2][0], _m[2][2]);
            vector._z = -PI * 0.5f;
            vector._y = 0.0f;
        }
    }
    else
    {
        vector._x = -GxMath::getATan2(-_m[2][0], _m[2][2]);
        vector._z = PI * 0.5f;
        vector._y = 0.0f;
    }
    return vector;
}
 
//---------------------------------------------------------------------------
// YXZ軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrixAffine::getRotateYXZ(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[1][2] < 1.0f )
    {
        if( _m[1][2] > -1.0f )
        {
            vector._y = -GxMath::getATan2(_m[0][2], _m[2][2]);
            vector._x = -GxMath::getASin(-_m[1][2]);
            vector._z = -GxMath::getATan2(_m[1][0], _m[1][1]);
        }
        else
        {
            vector._y = -GxMath::getATan2(_m[0][1], _m[0][0]);
            vector._x = -PI * 0.5f;
            vector._z = 0.0f;
        }
    }
    else
    {
        vector._y = -GxMath::getATan2(-_m[0][1], _m[0][0]);
        vector._x = PI * 0.5f;
        vector._z = 0.0f;
    }
    return vector;
}
 
//---------------------------------------------------------------------------
// YZX軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrixAffine::getRotateYZX(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[1][0] < 1.0f )
    {
        if( _m[1][0] > -1.0f )
        {
            vector._y = -GxMath::getATan2(-_m[2][0], _m[0][0]);
            vector._z = -GxMath::getASin(_m[1][0]);
            vector._x = -GxMath::getATan2(-_m[1][2], _m[1][1]);
        }
        else
        {
            vector._y = GxMath::getATan2(_m[2][1], _m[2][2]);
            vector._z = PI * 0.5f;
            vector._x = 0.0f;
        }
    }
    else
    {
        vector._y = -GxMath::getATan2(_m[2][1], _m[2][2]);
        vector._z = -PI * 0.5f;
        vector._x = 0.0f;
    }
    return vector;
}
 
//---------------------------------------------------------------------------
// ZXY軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrixAffine::getRotateZXY(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[2][1] < 1.0f )
    {
        if( _m[2][1] > -1.0f )
        {
            vector._z = -GxMath::getATan2(-_m[0][1], _m[1][1]);
            vector._x = -GxMath::getASin(_m[2][1]);
            vector._y = -GxMath::getATan2(-_m[2][0], _m[2][2]);
        }
        else
        {
            vector._z = GxMath::getATan2(_m[2][0], _m[0][0]);
            vector._x = PI * 0.5f;
            vector._y = 0.0f;
        }
    }
    else
    {
        vector._z = -GxMath::getATan2(_m[0][2], _m[0][0]);
        vector._x = -PI * 0.5f;
        vector._y = 0.0f;
    }
 
    return vector;
}
 
//---------------------------------------------------------------------------
// ZYX軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrixAffine::getRotateZYX(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[2][0] < 1.0f )
    {
        if( _m[2][0] > -1.0f )
        {
            vector._z = -GxMath::getATan2(_m[1][0], _m[0][0]);
            vector._y = -GxMath::getASin(-_m[2][0]);
            vector._x = -GxMath::getATan2(_m[2][1], _m[2][2]);
        }
        else
        {
            vector._z = GxMath::getATan2(_m[0][1], _m[0][2]);
            vector._y = -PI * 0.5f;
            vector._x = 0.0f;
        }
    }
    else
    {
        vector._z = -GxMath::getATan2(-_m[0][1], -_m[0][2]);
        vector._y = PI * 0.5f;
        vector._x = 0.0f;
    }
    
    return vector;
}
 
//---------------------------------------------------------------------------
// 平行移動行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setTranslate(const GxVector3& vector)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
 
    _m[3][0] = vector._x;
    _m[3][1] = vector._y;
    _m[3][2] = vector._z;
}
 
//---------------------------------------------------------------------------
// 平行移動行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setTranslate(f32 x, f32 y, f32 z)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
 
    _m[3][0] = x;
    _m[3][1] = y;
    _m[3][2] = z;
}
 
//---------------------------------------------------------------------------
// 平行移動量のみを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setPosition(const GxVector3& position)
{
    _m[3][0] = position._x;
    _m[3][1] = position._y;
    _m[3][2] = position._z;
}
 
//---------------------------------------------------------------------------
// 平行移動量のみを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setPosition(f32 x, f32 y, f32 z)
{
    _m[3][0] = x;
    _m[3][1] = y;
    _m[3][2] = z;
}
 
//---------------------------------------------------------------------------
// スケールを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrixAffine::getScale(void) const
{
    return GxVector3(
            reinterpret_cast<const GxVector3*>(&_m[0][0])->getLength(),
            reinterpret_cast<const GxVector3*>(&_m[1][0])->getLength(),
            reinterpret_cast<const GxVector3*>(&_m[2][0])->getLength()
        );
}
 
//---------------------------------------------------------------------------
// スケール行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setScale(const GxVector3& vector)
{
    _m[0][0] = vector._x;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = vector._y;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = vector._z;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
}
 
//---------------------------------------------------------------------------
// スケール行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setScale(f32 x, f32 y, f32 z)
{
    _m[0][0] = x;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = y;
    _m[1][2] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = z;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setRotateAxis(const GxVector3& vector, f32 radian)
{
    auto sinValue = GxMath::getSin(radian);
    auto cosValue = GxMath::getCos(radian);
 
    _m[0][0] = cosValue + vector._x * vector._x * (1.0f - cosValue);
    _m[0][1] = vector._x * vector._y * (1.0f - cosValue) + vector._z * sinValue;
    _m[0][2] = vector._x * vector._z * (1.0f - cosValue) - vector._y * sinValue;
 
    _m[1][0] = vector._x * vector._y * (1.0f - cosValue) - vector._z * sinValue;
    _m[1][1] = cosValue + vector._y * vector._y * (1.0f - cosValue);
    _m[1][2] = vector._y * vector._z * (1.0f - cosValue) + vector._x * sinValue;
 
    _m[2][0] = vector._x * vector._z * (1.0f - cosValue) + vector._y * sinValue;
    _m[2][1] = vector._y * vector._z * (1.0f - cosValue) - vector._x * sinValue;
    _m[2][2] = cosValue + vector._z * vector._z * (1.0f - cosValue);
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定
//
//---------------------------------------------------------------------------
GX_INLINE void GxMatrixAffine::setRotate(const GxQuaternion& quaternion)
{
    _m[0][0] = 1.0f - 2.0f * (quaternion._y * quaternion._y + quaternion._z * quaternion._z);
    _m[0][1] = 2.0f * (quaternion._x * quaternion._y + quaternion._w * quaternion._z);
    _m[0][2] = 2.0f * (quaternion._x * quaternion._z - quaternion._w * quaternion._y);
 
    _m[1][0] = 2.0f * (quaternion._x * quaternion._y - quaternion._w * quaternion._z);
    _m[1][1] = 1.0f - 2.0f * (quaternion._x * quaternion._x + quaternion._z * quaternion._z);
    _m[1][2] = 2.0f * (quaternion._y * quaternion._z + quaternion._w * quaternion._x);
 
    _m[2][0] = 2.0f * (quaternion._x * quaternion._z + quaternion._w * quaternion._y);
    _m[2][1] = 2.0f * (quaternion._y * quaternion._z - quaternion._w * quaternion._x);
    _m[2][2] = 1.0f - 2.0f * (quaternion._x * quaternion._x + quaternion._y * quaternion._y);
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
}
 
//---------------------------------------------------------------------------
// 行を取得
//---------------------------------------------------------------------------
const GxVector4& GxMatrixAffine::getRow(u32 row) const
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    const_cast<f32*>(_m[row])[3] = (row==3) ? 1.0f : 0.0f;  // パディングに代入
    return *reinterpret_cast<const GxVector4*>(&_m[row][0]);
}
 
//---------------------------------------------------------------------------
// 行のアドレスを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const f32*  GxMatrixAffine::getRowPtr(u32 row) const
{
    return &_m[row][0];
}
 
//---------------------------------------------------------------------------
// 行を設定
//
//---------------------------------------------------------------------------
void GxMatrixAffine::setRow(u32 row, const GxVector4& vector)
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    _m[row][0] = vector._x;
    _m[row][1] = vector._y;
    _m[row][2] = vector._z;
}
 
//---------------------------------------------------------------------------
// 行を設定
//
//---------------------------------------------------------------------------
void GxMatrixAffine::setRow(u32 row, const GxVector3& vector)
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    _m[row][0] = vector._x;
    _m[row][1] = vector._y;
    _m[row][2] = vector._z;
}
 
//---------------------------------------------------------------------------
// 列を取得
//---------------------------------------------------------------------------
GxVector4 GxMatrixAffine::getColumn(u32 column) const
{
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    return column == 3 ? GxVector4::AXIS_W : GxVector4(_m[0][column], _m[1][column], _m[2][column], _m[3][column]);
}
 
//---------------------------------------------------------------------------
// 列を設定
//
//---------------------------------------------------------------------------
void GxMatrixAffine::setColumn(u32 column, const GxVector4& vector)
{
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    if(column < 3)
    {
        _m[0][column] = vector._x;
        _m[1][column] = vector._y;
        _m[2][column] = vector._z;
        _m[3][column] = vector._w;
    }
}
 
//---------------------------------------------------------------------------
// 値を取得
//---------------------------------------------------------------------------
f32 GxMatrixAffine::getValue(u32 row, u32 column) const
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    if( column == 3 )
    {
        return GxVector4::AXIS_W[row];
    }
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 値を設定
//
//---------------------------------------------------------------------------
void GxMatrixAffine::setValue(u32 row, u32 column, f32 value)
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    if(column < 3)
    {
        _m[row][column] = value;
    }
}
 
//---------------------------------------------------------------------------
// 参照を取得
//---------------------------------------------------------------------------
f32& GxMatrixAffine::getReference(u32 row, u32 column)
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 3, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 参照を取得
//---------------------------------------------------------------------------
const f32& GxMatrixAffine::getReference(u32 row, u32 column) const
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 3, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 行列式の値を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxMatrixAffine::getDeterminant(void) const
{
    return _m[0][0] * (_m[1][1] * _m[2][2] - _m[2][1] * _m[1][2])
         - _m[0][1] * (_m[1][0] * _m[2][2] - _m[2][0] * _m[1][2])
         + _m[0][2] * (_m[1][0] * _m[2][1] - _m[2][0] * _m[1][1]);
}
 
//---------------------------------------------------------------------------
// 逆行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrixAffine GxMatrixAffine::getInverse(void) const
{
    GxMatrixAffine result(INIT::NONE);
    return GxMatrixAffine::getInverse(result, *this);
}
 
//---------------------------------------------------------------------------
// 転置行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrixAffine GxMatrixAffine::getTranspose(void) const
{
    return GxMatrixAffine(  _m[0][0], _m[1][0], _m[2][0],
                        _m[0][1], _m[1][1], _m[2][1],
                        _m[0][2], _m[1][2], _m[2][2],
                            0.0f,     0.0f,     0.0f);
}
 
//---------------------------------------------------------------------------
// 位置以外の各軸を正規化したものを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrixAffine GxMatrixAffine::getNormalizeAxes(void) const
{
    GxMatrixAffine matrix(getPosition());
 
    auto x = GxVector3(getRow(0)).getNormalizeEx();
    auto y = GxVector3(getRow(1)).getNormalizeEx();
    auto z = GxVector3(getRow(2)).getNormalizeEx();
 
    matrix.setRow(0, x);
    matrix.setRow(1, y);
    matrix.setRow(2, z);
 
    return matrix;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::getMulScalar(GxMatrixAffine& dst, const GxMatrixAffine& matrix, f32 scalar)
{
    dst._m[0][0] = matrix._m[0][0] * scalar;
    dst._m[0][1] = matrix._m[0][1] * scalar;
    dst._m[0][2] = matrix._m[0][2] * scalar;
 
    dst._m[1][0] = matrix._m[1][0] * scalar;
    dst._m[1][1] = matrix._m[1][1] * scalar;
    dst._m[1][2] = matrix._m[1][2] * scalar;
 
    dst._m[2][0] = matrix._m[2][0] * scalar;
    dst._m[2][1] = matrix._m[2][1] * scalar;
    dst._m[2][2] = matrix._m[2][2] * scalar;
 
    dst._m[3][0] = matrix._m[3][0] * scalar;
    dst._m[3][1] = matrix._m[3][1] * scalar;
    dst._m[3][2] = matrix._m[3][2] * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::getDivScalar(GxMatrixAffine& dst, const GxMatrixAffine& matrix, f32 scalar)
{
    auto inverseScalar = 1.0f / scalar;
 
    dst._m[0][0] = matrix._m[0][0] * inverseScalar;
    dst._m[0][1] = matrix._m[0][1] * inverseScalar;
    dst._m[0][2] = matrix._m[0][2] * inverseScalar;
 
    dst._m[1][0] = matrix._m[1][0] * inverseScalar;
    dst._m[1][1] = matrix._m[1][1] * inverseScalar;
    dst._m[1][2] = matrix._m[1][2] * inverseScalar;
 
    dst._m[2][0] = matrix._m[2][0] * inverseScalar;
    dst._m[2][1] = matrix._m[2][1] * inverseScalar;
    dst._m[2][2] = matrix._m[2][2] * inverseScalar;
 
    dst._m[3][0] = matrix._m[3][0] * inverseScalar;
    dst._m[3][1] = matrix._m[3][1] * inverseScalar;
    dst._m[3][2] = matrix._m[3][2] * inverseScalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::getAddMatrix(GxMatrixAffine& dst, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1)
{
    dst._m[0][0] = matrix0._m[0][0] + matrix1._m[0][0];
    dst._m[0][1] = matrix0._m[0][1] + matrix1._m[0][1];
    dst._m[0][2] = matrix0._m[0][2] + matrix1._m[0][2];
 
    dst._m[1][0] = matrix0._m[1][0] + matrix1._m[1][0];
    dst._m[1][1] = matrix0._m[1][1] + matrix1._m[1][1];
    dst._m[1][2] = matrix0._m[1][2] + matrix1._m[1][2];
 
    dst._m[2][0] = matrix0._m[2][0] + matrix1._m[2][0];
    dst._m[2][1] = matrix0._m[2][1] + matrix1._m[2][1];
    dst._m[2][2] = matrix0._m[2][2] + matrix1._m[2][2];
 
    dst._m[3][0] = matrix0._m[3][0] + matrix1._m[3][0];
    dst._m[3][1] = matrix0._m[3][1] + matrix1._m[3][1];
    dst._m[3][2] = matrix0._m[3][2] + matrix1._m[3][2];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::getMulMatrix(GxMatrixAffine& dst, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1)
{
#if defined(GX_USE_SSE2)
    __declspec(align(16)) static const u32 masktable[4] = {0xffffffff,0xffffffff,0xffffffff,0x00000000};
 
    __m128 mask = _mm_load_ps( (const f32*)masktable );
    __m128 r0 = _mm_and_ps( matrix1._r[0], mask );
    __m128 r1 = _mm_and_ps( matrix1._r[1], mask );
    __m128 r2 = _mm_and_ps( matrix1._r[2], mask );
    __m128 r3 = _mm_and_ps( matrix1._r[3], mask );
 
    __m128 mx;
    __m128 my;
    __m128 mz;
    __m128 row;
 
    row = matrix0._r[0];
    mx = _mm_mul_ps(r0, SPLATX(row) );
    my = _mm_mul_ps(r1, SPLATY(row) );
    mz = _mm_mul_ps(r2, SPLATZ(row) );
    dst._r[0] = _mm_add_ps(_mm_add_ps(mx,my), mz);
 
    row = matrix0._r[1];
    mx = _mm_mul_ps(r0, SPLATX(row) );
    my = _mm_mul_ps(r1, SPLATY(row) );
    mz = _mm_mul_ps(r2, SPLATZ(row) );
    dst._r[1] = _mm_add_ps(_mm_add_ps(mx,my), mz);
 
    row = matrix0._r[2];
    mx = _mm_mul_ps(r0, SPLATX(row) );
    my = _mm_mul_ps(r1, SPLATY(row) );
    mz = _mm_mul_ps(r2, SPLATZ(row) );
    dst._r[2] = _mm_add_ps(_mm_add_ps(mx,my), mz);
 
    row = matrix0._r[3];
    mx = _mm_mul_ps(r0, SPLATX(row) );
    my = _mm_mul_ps(r1, SPLATY(row) );
    mz = _mm_mul_ps(r2, SPLATZ(row) );
    dst._r[3] = _mm_add_ps(_mm_add_ps(mx,my), _mm_add_ps(mz,r3));
 
#else //GX_USE_SSE2
    // 入力と出力が同じ行列だった場合を考慮して、一時変数で計算する
    const auto m00 = matrix0._m[0][0] * matrix1._m[0][0] + matrix0._m[0][1] * matrix1._m[1][0] + matrix0._m[0][2] * matrix1._m[2][0];
    const auto m01 = matrix0._m[0][0] * matrix1._m[0][1] + matrix0._m[0][1] * matrix1._m[1][1] + matrix0._m[0][2] * matrix1._m[2][1];
    const auto m02 = matrix0._m[0][0] * matrix1._m[0][2] + matrix0._m[0][1] * matrix1._m[1][2] + matrix0._m[0][2] * matrix1._m[2][2];
 
    const auto m10 = matrix0._m[1][0] * matrix1._m[0][0] + matrix0._m[1][1] * matrix1._m[1][0] + matrix0._m[1][2] * matrix1._m[2][0];
    const auto m11 = matrix0._m[1][0] * matrix1._m[0][1] + matrix0._m[1][1] * matrix1._m[1][1] + matrix0._m[1][2] * matrix1._m[2][1];
    const auto m12 = matrix0._m[1][0] * matrix1._m[0][2] + matrix0._m[1][1] * matrix1._m[1][2] + matrix0._m[1][2] * matrix1._m[2][2];
 
    const auto m20 = matrix0._m[2][0] * matrix1._m[0][0] + matrix0._m[2][1] * matrix1._m[1][0] + matrix0._m[2][2] * matrix1._m[2][0];
    const auto m21 = matrix0._m[2][0] * matrix1._m[0][1] + matrix0._m[2][1] * matrix1._m[1][1] + matrix0._m[2][2] * matrix1._m[2][1];
    const auto m22 = matrix0._m[2][0] * matrix1._m[0][2] + matrix0._m[2][1] * matrix1._m[1][2] + matrix0._m[2][2] * matrix1._m[2][2];
 
    const auto m30 = matrix0._m[3][0] * matrix1._m[0][0] + matrix0._m[3][1] * matrix1._m[1][0] + matrix0._m[3][2] * matrix1._m[2][0] + matrix1._m[3][0];
    const auto m31 = matrix0._m[3][0] * matrix1._m[0][1] + matrix0._m[3][1] * matrix1._m[1][1] + matrix0._m[3][2] * matrix1._m[2][1] + matrix1._m[3][1];
    const auto m32 = matrix0._m[3][0] * matrix1._m[0][2] + matrix0._m[3][1] * matrix1._m[1][2] + matrix0._m[3][2] * matrix1._m[2][2] + matrix1._m[3][2];
 
    dst._m[0][0] = m00;
    dst._m[0][1] = m01;
    dst._m[0][2] = m02;
 
    dst._m[1][0] = m10;
    dst._m[1][1] = m11;
    dst._m[1][2] = m12;
 
    dst._m[2][0] = m20;
    dst._m[2][1] = m21;
    dst._m[2][2] = m22;
 
    dst._m[3][0] = m30;
    dst._m[3][1] = m31;
    dst._m[3][2] = m32;
#endif // !GX_USE_SSE2
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::getFastMulMatrix(GxMatrixAffine& dst, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1)
{
#if defined(GX_USE_SSE2)
    __m128 mx;
    __m128 my;
    __m128 mz;
    __m128 m0r;
 
    __m128 m1x = _mm_load_ps(&matrix1._m[0][0]);
    __m128 m1y = _mm_load_ps(&matrix1._m[1][0]);
    __m128 m1z = _mm_load_ps(&matrix1._m[2][0]);
    __m128 m1w = _mm_load_ps(&matrix1._m[3][0]);
 
    m0r = _mm_load_ps(&matrix0._m[0][0]);
    mx = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(0,0,0,0)), m1x );
    my = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(1,1,1,1)), m1y );
    mz = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(2,2,2,2)), m1z );
    _mm_store_ps(&dst._m[0][0], _mm_add_ps( _mm_add_ps(mx, my), mz ));
 
    m0r = _mm_load_ps(&matrix0._m[1][0]);
    mx = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(0,0,0,0)), m1x );
    my = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(1,1,1,1)), m1y );
    mz = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(2,2,2,2)), m1z );
    _mm_store_ps(&dst._m[1][0], _mm_add_ps( _mm_add_ps(mx, my), mz ));
 
    m0r = _mm_load_ps(&matrix0._m[2][0]);
    mx = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(0,0,0,0)), m1x );
    my = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(1,1,1,1)), m1y );
    mz = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(2,2,2,2)), m1z );
    _mm_store_ps(&dst._m[2][0], _mm_add_ps( _mm_add_ps(mx, my), mz ));
 
    m0r = _mm_load_ps(&matrix0._m[3][0]);
    mx = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(0,0,0,0)), m1x );
    my = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(1,1,1,1)), m1y );
    mz = _mm_mul_ps( _mm_permute_ps(m0r, _MM_SHUFFLE(2,2,2,2)), m1z );
    _mm_store_ps(&dst._m[3][0], _mm_add_ps(_mm_add_ps(mx, my), _mm_add_ps(mz, m1w)));
#else //GX_USE_SSE2
    dst._m[0][0] = matrix0._m[0][0] * matrix1._m[0][0] + matrix0._m[0][1] * matrix1._m[1][0] + matrix0._m[0][2] * matrix1._m[2][0];
    dst._m[0][1] = matrix0._m[0][0] * matrix1._m[0][1] + matrix0._m[0][1] * matrix1._m[1][1] + matrix0._m[0][2] * matrix1._m[2][1];
    dst._m[0][2] = matrix0._m[0][0] * matrix1._m[0][2] + matrix0._m[0][1] * matrix1._m[1][2] + matrix0._m[0][2] * matrix1._m[2][2];
 
    dst._m[1][0] = matrix0._m[1][0] * matrix1._m[0][0] + matrix0._m[1][1] * matrix1._m[1][0] + matrix0._m[1][2] * matrix1._m[2][0];
    dst._m[1][1] = matrix0._m[1][0] * matrix1._m[0][1] + matrix0._m[1][1] * matrix1._m[1][1] + matrix0._m[1][2] * matrix1._m[2][1];
    dst._m[1][2] = matrix0._m[1][0] * matrix1._m[0][2] + matrix0._m[1][1] * matrix1._m[1][2] + matrix0._m[1][2] * matrix1._m[2][2];
 
    dst._m[2][0] = matrix0._m[2][0] * matrix1._m[0][0] + matrix0._m[2][1] * matrix1._m[1][0] + matrix0._m[2][2] * matrix1._m[2][0];
    dst._m[2][1] = matrix0._m[2][0] * matrix1._m[0][1] + matrix0._m[2][1] * matrix1._m[1][1] + matrix0._m[2][2] * matrix1._m[2][1];
    dst._m[2][2] = matrix0._m[2][0] * matrix1._m[0][2] + matrix0._m[2][1] * matrix1._m[1][2] + matrix0._m[2][2] * matrix1._m[2][2];
 
    dst._m[3][0] = matrix0._m[3][0] * matrix1._m[0][0] + matrix0._m[3][1] * matrix1._m[1][0] + matrix0._m[3][2] * matrix1._m[2][0] + matrix1._m[3][0];
    dst._m[3][1] = matrix0._m[3][0] * matrix1._m[0][1] + matrix0._m[3][1] * matrix1._m[1][1] + matrix0._m[3][2] * matrix1._m[2][1] + matrix1._m[3][1];
    dst._m[3][2] = matrix0._m[3][0] * matrix1._m[0][2] + matrix0._m[3][1] * matrix1._m[1][2] + matrix0._m[3][2] * matrix1._m[2][2] + matrix1._m[3][2];
#endif // !GX_USE_SSE2
}
 
//---------------------------------------------------------------------------
// simd 用にアライメントされているか調べる
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrixAffine::isSimdAlignment(const GxMatrixAffine& matrix)
{
    return !(reinterpret_cast<size_t>(matrix._m) & (16 - 1)); // 16byte
}
 
//---------------------------------------------------------------------------
// 行列乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffineGpu& GxMatrixAffine::getMulMatrix(GxMatrixAffineGpu& dst, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1)
{
#if defined(GX_USE_SSE2)
    __declspec(align(16)) static const u32 masktable[4] = {0xffffffff,0xffffffff,0xffffffff,0x00000000};
 
    __m128 mask = _mm_load_ps( (const f32*)masktable );
    __m128 r0 = _mm_and_ps( matrix1._r[0], mask );
    __m128 r1 = _mm_and_ps( matrix1._r[1], mask );
    __m128 r2 = _mm_and_ps( matrix1._r[2], mask );
    __m128 r3 = _mm_and_ps( matrix1._r[3], mask );
 
    __m128 lr0 = matrix0._r[0];
    __m128 lr1 = matrix0._r[1];
    __m128 lr2 = matrix0._r[2];
    __m128 lr3 = matrix0._r[3];
    __m128 v;
    __m128 mx;
    __m128 my;
    __m128 mz;
 
    mx = _mm_mul_ps(r0, _mm_shuffle_ps(lr0, lr0, _MM_SHUFFLE(0,0,0,0)) );
    my = _mm_mul_ps(r1, _mm_shuffle_ps(lr0, lr0, _MM_SHUFFLE(1,1,1,1)) );
    mz = _mm_mul_ps(r2, _mm_shuffle_ps(lr0, lr0, _MM_SHUFFLE(2,2,2,2)) );
    v  = _mm_add_ps(_mm_add_ps(mx,my), mz);
    _mm_store_ss( &dst._m[0][0], v );
    _mm_store_ss( &dst._m[1][0], _mm_shuffle_ps(v, v, _MM_SHUFFLE(1,1,1,1)) );
    _mm_store_ss( &dst._m[2][0], _mm_shuffle_ps(v, v, _MM_SHUFFLE(2,2,2,2)) );
 
    mx = _mm_mul_ps(r0, _mm_shuffle_ps(lr1, lr1, _MM_SHUFFLE(0,0,0,0)) );
    my = _mm_mul_ps(r1, _mm_shuffle_ps(lr1, lr1, _MM_SHUFFLE(1,1,1,1)) );
    mz = _mm_mul_ps(r2, _mm_shuffle_ps(lr1, lr1, _MM_SHUFFLE(2,2,2,2)) );
    v  = _mm_add_ps(_mm_add_ps(mx,my), mz);
    _mm_store_ss( &dst._m[0][1], v );
    _mm_store_ss( &dst._m[1][1], _mm_shuffle_ps(v, v, _MM_SHUFFLE(1,1,1,1)) );
    _mm_store_ss( &dst._m[2][1], _mm_shuffle_ps(v, v, _MM_SHUFFLE(2,2,2,2)) );
 
    mx = _mm_mul_ps(r0, _mm_shuffle_ps(lr2, lr2, _MM_SHUFFLE(0,0,0,0)) );
    my = _mm_mul_ps(r1, _mm_shuffle_ps(lr2, lr2, _MM_SHUFFLE(1,1,1,1)) );
    mz = _mm_mul_ps(r2, _mm_shuffle_ps(lr2, lr2, _MM_SHUFFLE(2,2,2,2)) );
    v  = _mm_add_ps(_mm_add_ps(mx,my), mz);
    _mm_store_ss( &dst._m[0][2], v );
    _mm_store_ss( &dst._m[1][2], _mm_shuffle_ps(v, v, _MM_SHUFFLE(1,1,1,1)) );
    _mm_store_ss( &dst._m[2][2], _mm_shuffle_ps(v, v, _MM_SHUFFLE(2,2,2,2)) );
 
    mx = _mm_mul_ps(r0, _mm_shuffle_ps(lr3, lr3, _MM_SHUFFLE(0,0,0,0)) );
    my = _mm_mul_ps(r1, _mm_shuffle_ps(lr3, lr3, _MM_SHUFFLE(1,1,1,1)) );
    mz = _mm_mul_ps(r2, _mm_shuffle_ps(lr3, lr3, _MM_SHUFFLE(2,2,2,2)) );
    v  = _mm_add_ps(_mm_add_ps(mx,my), _mm_add_ps(mz,r3));
    _mm_store_ss( &dst._m[0][3], v );
    _mm_store_ss( &dst._m[1][3], _mm_shuffle_ps(v, v, _MM_SHUFFLE(1,1,1,1)) );
    _mm_store_ss( &dst._m[2][3], _mm_shuffle_ps(v, v, _MM_SHUFFLE(2,2,2,2)) );
 
#else //GX_USE_SSE2
    // 入力と出力が同じ行列だった場合を考慮して、一時変数で計算する
    const auto m00 = matrix0._m[0][0] * matrix1._m[0][0] + matrix0._m[0][1] * matrix1._m[1][0] + matrix0._m[0][2] * matrix1._m[2][0];
    const auto m01 = matrix0._m[0][0] * matrix1._m[0][1] + matrix0._m[0][1] * matrix1._m[1][1] + matrix0._m[0][2] * matrix1._m[2][1];
    const auto m02 = matrix0._m[0][0] * matrix1._m[0][2] + matrix0._m[0][1] * matrix1._m[1][2] + matrix0._m[0][2] * matrix1._m[2][2];
 
    const auto m10 = matrix0._m[1][0] * matrix1._m[0][0] + matrix0._m[1][1] * matrix1._m[1][0] + matrix0._m[1][2] * matrix1._m[2][0];
    const auto m11 = matrix0._m[1][0] * matrix1._m[0][1] + matrix0._m[1][1] * matrix1._m[1][1] + matrix0._m[1][2] * matrix1._m[2][1];
    const auto m12 = matrix0._m[1][0] * matrix1._m[0][2] + matrix0._m[1][1] * matrix1._m[1][2] + matrix0._m[1][2] * matrix1._m[2][2];
 
    const auto m20 = matrix0._m[2][0] * matrix1._m[0][0] + matrix0._m[2][1] * matrix1._m[1][0] + matrix0._m[2][2] * matrix1._m[2][0];
    const auto m21 = matrix0._m[2][0] * matrix1._m[0][1] + matrix0._m[2][1] * matrix1._m[1][1] + matrix0._m[2][2] * matrix1._m[2][1];
    const auto m22 = matrix0._m[2][0] * matrix1._m[0][2] + matrix0._m[2][1] * matrix1._m[1][2] + matrix0._m[2][2] * matrix1._m[2][2];
 
    const auto m30 = matrix0._m[3][0] * matrix1._m[0][0] + matrix0._m[3][1] * matrix1._m[1][0] + matrix0._m[3][2] * matrix1._m[2][0] + matrix1._m[3][0];
    const auto m31 = matrix0._m[3][0] * matrix1._m[0][1] + matrix0._m[3][1] * matrix1._m[1][1] + matrix0._m[3][2] * matrix1._m[2][1] + matrix1._m[3][1];
    const auto m32 = matrix0._m[3][0] * matrix1._m[0][2] + matrix0._m[3][1] * matrix1._m[1][2] + matrix0._m[3][2] * matrix1._m[2][2] + matrix1._m[3][2];
 
    dst._m[0][0] = m00;
    dst._m[1][0] = m01;
    dst._m[2][0] = m02;
 
    dst._m[0][1] = m10;
    dst._m[1][1] = m11;
    dst._m[2][1] = m12;
 
    dst._m[0][2] = m20;
    dst._m[1][2] = m21;
    dst._m[2][2] = m22;
 
    dst._m[0][3] = m30;
    dst._m[1][3] = m31;
    dst._m[2][3] = m32;
#endif // !GX_USE_SSE2
    return dst;
}
 
#if defined(GX_USE_SSE2)
GX_FORCE_INLINE __m128 getDeterminantFrom33_SSE( __m128 r0, __m128 r1, __m128 r2 )
{
    __m128 m0 = _mm_shuffle_ps(r1, r1, _MM_SHUFFLE(0,0,0,1) );
    __m128 m1 = _mm_shuffle_ps(r2, r2, _MM_SHUFFLE(0,1,2,2) );
    __m128 m2 = _mm_shuffle_ps(r2, r2, _MM_SHUFFLE(0,0,0,1) );
    __m128 m3 = _mm_shuffle_ps(r1, r1, _MM_SHUFFLE(0,1,2,2) );
    m0 = _mm_mul_ps( r0, _mm_sub_ps( _mm_mul_ps( m0, m1 ), _mm_mul_ps( m2, m3 ) ) );
    return _mm_sub_ps( _mm_add_ps( SPLATX(m0), SPLATZ(m0) ), SPLATY(m0) );
}
 
GX_FORCE_INLINE __m128 getRcpDeterminant_SSE( const GxMatrixAffine& matrix )
{
    __m128 m0 = _mm_shuffle_ps(matrix._r[1], matrix._r[1], _MM_SHUFFLE(0,0,0,1) );
    __m128 m1 = _mm_shuffle_ps(matrix._r[2], matrix._r[2], _MM_SHUFFLE(0,1,2,2) );
    __m128 m2 = _mm_shuffle_ps(matrix._r[2], matrix._r[2], _MM_SHUFFLE(0,0,0,1) );
    __m128 m3 = _mm_shuffle_ps(matrix._r[1], matrix._r[1], _MM_SHUFFLE(0,1,2,2) );
    m0 = _mm_mul_ps( matrix._r[0], _mm_sub_ps( _mm_mul_ps( m0, m1 ), _mm_mul_ps( m2, m3 ) ) );
    m0 = _mm_sub_ps( _mm_add_ps( SPLATX(m0), SPLATZ(m0) ), SPLATY(m0) );
    m0 = _mm_rcp_ps_22bit(m0);
    return m0;
}
#endif //GX_USE_SSE2
 
//---------------------------------------------------------------------------
// 逆行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::getInverse(GxMatrixAffine& dst, const GxMatrixAffine& matrix)
{
#if defined(GX_USE_SSE2)
    __m128 d = getRcpDeterminant_SSE( matrix );
 
    const f32 m00 = matrix._m[1][1] * matrix._m[2][2] - matrix._m[1][2] * matrix._m[2][1];
    const f32 m01 =-matrix._m[0][1] * matrix._m[2][2] + matrix._m[0][2] * matrix._m[2][1];
    const f32 m02 = matrix._m[0][1] * matrix._m[1][2] - matrix._m[0][2] * matrix._m[1][1];
 
    const f32 m10 =-matrix._m[1][0] * matrix._m[2][2] + matrix._m[1][2] * matrix._m[2][0];
    const f32 m11 = matrix._m[0][0] * matrix._m[2][2] - matrix._m[0][2] * matrix._m[2][0];
    const f32 m12 =-matrix._m[0][0] * matrix._m[1][2] + matrix._m[0][2] * matrix._m[1][0];
 
    const f32 m20 = matrix._m[1][0] * matrix._m[2][1] - matrix._m[1][1] * matrix._m[2][0];
    const f32 m21 =-matrix._m[0][0] * matrix._m[2][1] + matrix._m[0][1] * matrix._m[2][0];
    const f32 m22 = matrix._m[0][0] * matrix._m[1][1] - matrix._m[0][1] * matrix._m[1][0];
 
    __m128 m30 = getDeterminantFrom33_SSE(matrix._r[1], matrix._r[2], matrix._r[3]);
    __m128 m31 = getDeterminantFrom33_SSE(matrix._r[0], matrix._r[2], matrix._r[3]);
    __m128 m32 = getDeterminantFrom33_SSE(matrix._r[0], matrix._r[1], matrix._r[3]);
    dst._r[0] = _mm_mul_ps( _mm_set_ps(0.0f, m02, m01, m00), d );
    dst._r[1] = _mm_mul_ps( _mm_set_ps(0.0f, m12, m11, m10), d );
    dst._r[2] = _mm_mul_ps( _mm_set_ps(0.0f, m22, m21, m20), d );
    dst._r[3] = _mm_mul_ps( _mm_mul_ps( _mm_unpacklo_ps( _mm_unpacklo_ps( m30, m32 ), m31 ), _mm_set_ps( 0.0f, -1.0f, 1.0f, -1.0f ) ), d );
#else //GX_USE_SSE2
    const auto m00 = matrix._m[1][1] * matrix._m[2][2] - matrix._m[1][2] * matrix._m[2][1];
    const auto m01 =-matrix._m[0][1] * matrix._m[2][2] + matrix._m[0][2] * matrix._m[2][1];
    const auto m02 = matrix._m[0][1] * matrix._m[1][2] - matrix._m[0][2] * matrix._m[1][1];
 
    const auto m10 =-matrix._m[1][0] * matrix._m[2][2] + matrix._m[1][2] * matrix._m[2][0];
    const auto m11 = matrix._m[0][0] * matrix._m[2][2] - matrix._m[0][2] * matrix._m[2][0];
    const auto m12 =-matrix._m[0][0] * matrix._m[1][2] + matrix._m[0][2] * matrix._m[1][0];
 
    const auto m20 = matrix._m[1][0] * matrix._m[2][1] - matrix._m[1][1] * matrix._m[2][0];
    const auto m21 =-matrix._m[0][0] * matrix._m[2][1] + matrix._m[0][1] * matrix._m[2][0];
    const auto m22 = matrix._m[0][0] * matrix._m[1][1] - matrix._m[0][1] * matrix._m[1][0];
 
    const auto m30 = -GxMatrix33(matrix._m[1][0], matrix._m[1][1], matrix._m[1][2], matrix._m[2][0], matrix._m[2][1], matrix._m[2][2], matrix._m[3][0], matrix._m[3][1], matrix._m[3][2]).getDeterminant();
    const auto m31 =  GxMatrix33(matrix._m[0][0], matrix._m[0][1], matrix._m[0][2], matrix._m[2][0], matrix._m[2][1], matrix._m[2][2], matrix._m[3][0], matrix._m[3][1], matrix._m[3][2]).getDeterminant();
    const auto m32 = -GxMatrix33(matrix._m[0][0], matrix._m[0][1], matrix._m[0][2], matrix._m[1][0], matrix._m[1][1], matrix._m[1][2], matrix._m[3][0], matrix._m[3][1], matrix._m[3][2]).getDeterminant();
 
    const auto d = 1.0f / matrix.getDeterminant();
 
    dst._m[0][0] = m00 * d;
    dst._m[0][1] = m01 * d;
    dst._m[0][2] = m02 * d;
 
    dst._m[1][0] = m10 * d;
    dst._m[1][1] = m11 * d;
    dst._m[1][2] = m12 * d;
 
    dst._m[2][0] = m20 * d;
    dst._m[2][1] = m21 * d;
    dst._m[2][2] = m22 * d;
 
    dst._m[3][0] = m30 * d;
    dst._m[3][1] = m31 * d;
    dst._m[3][2] = m32 * d;
#endif // !GX_USE_SSE2
    return dst;
}
//---------------------------------------------------------------------------
// 転置行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::getTranspose(GxMatrixAffine& dst, const GxMatrixAffine& matrix)
{
    const auto m00 = matrix._m[0][0];
    const auto m01 = matrix._m[1][0];
    const auto m02 = matrix._m[2][0];
                    
    const auto m10 = matrix._m[0][1];
    const auto m11 = matrix._m[1][1];
    const auto m12 = matrix._m[2][1];
                    
    const auto m20 = matrix._m[0][2];
    const auto m21 = matrix._m[1][2];
    const auto m22 = matrix._m[2][2];
 
    dst._m[0][0] = m00;
    dst._m[0][1] = m01;
    dst._m[0][2] = m02;
                   
    dst._m[1][0] = m10;
    dst._m[1][1] = m11;
    dst._m[1][2] = m12;
                   
    dst._m[2][0] = m20;
    dst._m[2][1] = m21;
    dst._m[2][2] = m22;
 
    dst._m[3][0] = 0.0f;
    dst._m[3][1] = 0.0f;
    dst._m[3][2] = 0.0f;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulScalar(f32 scalar)
{
    _m[0][0] *= scalar;
    _m[0][1] *= scalar;
    _m[0][2] *= scalar;
 
    _m[1][0] *= scalar;
    _m[1][1] *= scalar;
    _m[1][2] *= scalar;
 
    _m[2][0] *= scalar;
    _m[2][1] *= scalar;
    _m[2][2] *= scalar;
 
    _m[3][0] *= scalar;
    _m[3][1] *= scalar;
    _m[3][2] *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::divScalar(f32 scalar)
{
    auto invScalar = 1.0f / scalar;
 
    _m[0][0] *= invScalar;
    _m[0][1] *= invScalar;
    _m[0][2] *= invScalar;
 
    _m[1][0] *= invScalar;
    _m[1][1] *= invScalar;
    _m[1][2] *= invScalar;
 
    _m[2][0] *= invScalar;
    _m[2][1] *= invScalar;
    _m[2][2] *= invScalar;
 
    _m[3][0] *= invScalar;
    _m[3][1] *= invScalar;
    _m[3][2] *= invScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::addMatrix(const GxMatrixAffine& matrix)
{
    _m[0][0] += matrix._m[0][0];
    _m[0][1] += matrix._m[0][1];
    _m[0][2] += matrix._m[0][2];
 
    _m[1][0] += matrix._m[1][0];
    _m[1][1] += matrix._m[1][1];
    _m[1][2] += matrix._m[1][2];
 
    _m[2][0] += matrix._m[2][0];
    _m[2][1] += matrix._m[2][1];
    _m[2][2] += matrix._m[2][2];
 
    _m[3][0] += matrix._m[3][0];
    _m[3][1] += matrix._m[3][1];
    _m[3][2] += matrix._m[3][2];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulMatrix(const GxMatrixAffine& matrix)
{
    getMulMatrix( *this, *this, matrix);
    return *this;
}
 
//---------------------------------------------------------------------------
// X軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulRotateX(f32 radian)
{
    GxMatrixAffine matrix(INIT::NONE);
    matrix.setRotateX(radian);
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// Y軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulRotateY(f32 radian)
{
    GxMatrixAffine matrix(INIT::NONE);
    matrix.setRotateY(radian);
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// Z軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulRotateZ(f32 radian)
{
    GxMatrixAffine matrix(INIT::NONE);
    matrix.setRotateZ(radian);
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオンによる回転乗算(前から乗算)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulQuaternionFront(const GxQuaternion& quaternion)
{
    GxMatrixAffine matrix(quaternion);
    GxMatrixAffine::getMulMatrix(*this, matrix, *this);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオンによる回転乗算(後ろから乗算)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulQuaternionBack(const GxQuaternion& quaternion)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrixAffine matrix(quaternion);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
 
#if defined(GX_USE_SSE2)
    __m128 q = _mm_loadu_ps( &quaternion._x );
#define _SHF_YXX _MM_SHUFFLE(3,0,0,1)
#define _SHF_ZZY _MM_SHUFFLE(3,1,2,2)
 
#define _SHF_XYX _MM_SHUFFLE(3,0,1,0)
#define _SHF_YZZ _MM_SHUFFLE(3,2,2,1)
#define _SHF_WWW _MM_SHUFFLE(3,3,3,3)
#define _SHF_ZXY _MM_SHUFFLE(3,1,0,2)
 
#define _SHF_XXY _MM_SHUFFLE(3,1,0,0)
#define _SHF_ZYZ _MM_SHUFFLE(3,2,1,2)
#define _SHF_YZX _MM_SHUFFLE(3,0,2,1)
 
 
    __m128 v0,v1,v2,v3;
    __m128 r0,r1,r2;
    __m128 t0,t1,t2;
 
    __m128 c0 = _mm_set_ps(+0.0f,+1.0f,+1.0f,+1.0f);
    __m128 c1 = _mm_set_ps(+0.0f,-2.0f,-2.0f,-2.0f);
    __m128 c2 = _mm_set_ps(+0.0f,+2.0f,+2.0f,+2.0f);
 
    v0 = _mm_shuffle_ps(q, q, _SHF_YXX);    
    v1 = _mm_shuffle_ps(q, q, _SHF_ZZY);
 
    t0 = _mm_add_ps( _mm_mul_ps( v0, v0 ), _mm_mul_ps( v1, v1 ) );
    t0 = _mm_add_ps( c0, _mm_mul_ps( c1, t0 ) );
 
    v0 = _mm_shuffle_ps(q, q, _SHF_XYX);    
    v1 = _mm_shuffle_ps(q, q, _SHF_YZZ);
    v2 = _mm_shuffle_ps(q, q, _SHF_WWW);    
    v3 = _mm_shuffle_ps(q, q, _SHF_ZXY);
 
    v0 = _mm_mul_ps( v0, v1 );
    v1 = _mm_mul_ps( v2, v3 );
    t1 = _mm_mul_ps( c2, _mm_add_ps( v0, v1 ) );
 
    v0 = _mm_shuffle_ps(v0, v0, _MM_SHUFFLE(3,1,0,2) ); 
    v1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3,1,0,2) );
 
    t2 = _mm_mul_ps( c2, _mm_sub_ps( v0, v1 ) );
 
    r0 = _mm_unpacklo_ps( _mm_unpacklo_ps( t0, t2 ), _mm_unpacklo_ps( t1, _mm_setzero_ps() ) );
    r1 = _mm_unpackhi_ps( _mm_unpacklo_ps( t2, t1 ), _mm_unpacklo_ps( t0, _mm_setzero_ps() ) );
    r2 = _mm_unpacklo_ps( _mm_unpackhi_ps( t1, t0 ), _mm_unpackhi_ps( t2, _mm_setzero_ps() ) );
 
    __m128 m00 = _r[0];
    __m128 m10 = _r[1];
    __m128 m20 = _r[2];
    __m128 m30 = _r[3];
 
    _r[0] = _mm_add_ps( _mm_add_ps( _mm_mul_ps( SPLATX(m00), r0 ), _mm_mul_ps( SPLATY(m00), r1 ) ), _mm_mul_ps( SPLATZ(m00), r2 ) );
    _r[1] = _mm_add_ps( _mm_add_ps( _mm_mul_ps( SPLATX(m10), r0 ), _mm_mul_ps( SPLATY(m10), r1 ) ), _mm_mul_ps( SPLATZ(m10), r2 ) );
    _r[2] = _mm_add_ps( _mm_add_ps( _mm_mul_ps( SPLATX(m20), r0 ), _mm_mul_ps( SPLATY(m20), r1 ) ), _mm_mul_ps( SPLATZ(m20), r2 ) );
    _r[3] = _mm_add_ps( _mm_add_ps( _mm_mul_ps( SPLATX(m30), r0 ), _mm_mul_ps( SPLATY(m30), r1 ) ), _mm_mul_ps( SPLATZ(m30), r2 ) );
#else //GX_USE_SSE2
    const auto r00 = 1.0f - 2.0f * (quaternion._y * quaternion._y + quaternion._z * quaternion._z);
    const auto r01 = 2.0f * (quaternion._x * quaternion._y + quaternion._w * quaternion._z);
    const auto r02 = 2.0f * (quaternion._x * quaternion._z - quaternion._w * quaternion._y);
 
    const auto r10 = 2.0f * (quaternion._x * quaternion._y - quaternion._w * quaternion._z);
    const auto r11 = 1.0f - 2.0f * (quaternion._x * quaternion._x + quaternion._z * quaternion._z);
    const auto r12 = 2.0f * (quaternion._y * quaternion._z + quaternion._w * quaternion._x);
 
    const auto r20 = 2.0f * (quaternion._x * quaternion._z + quaternion._w * quaternion._y);
    const auto r21 = 2.0f * (quaternion._y * quaternion._z - quaternion._w * quaternion._x);
    const auto r22 = 1.0f - 2.0f * (quaternion._x * quaternion._x + quaternion._y * quaternion._y);
 
    const auto m00 = _m[0][0] * r00 + _m[0][1] * r10 + _m[0][2] * r20;
    const auto m01 = _m[0][0] * r01 + _m[0][1] * r11 + _m[0][2] * r21;
    const auto m02 = _m[0][0] * r02 + _m[0][1] * r12 + _m[0][2] * r22;
 
    const auto m10 = _m[1][0] * r00 + _m[1][1] * r10 + _m[1][2] * r20;
    const auto m11 = _m[1][0] * r01 + _m[1][1] * r11 + _m[1][2] * r21;
    const auto m12 = _m[1][0] * r02 + _m[1][1] * r12 + _m[1][2] * r22;
 
    const auto m20 = _m[2][0] * r00 + _m[2][1] * r10 + _m[2][2] * r20;
    const auto m21 = _m[2][0] * r01 + _m[2][1] * r11 + _m[2][2] * r21;
    const auto m22 = _m[2][0] * r02 + _m[2][1] * r12 + _m[2][2] * r22;
 
    const auto m30 = _m[3][0] * r00 + _m[3][1] * r10 + _m[3][2] * r20;
    const auto m31 = _m[3][0] * r01 + _m[3][1] * r11 + _m[3][2] * r21;
    const auto m32 = _m[3][0] * r02 + _m[3][1] * r12 + _m[3][2] * r22;
 
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
 
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
 
    _m[3][0] = m30;
    _m[3][1] = m31;
    _m[3][2] = m32;
#endif // !GX_USE_SSE2
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スケール行列を設定し、クォータニオンによる回転乗算(後ろから乗算)を行う
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrixAffine::setScaleQuaternion(const GxVector3& scale, const GxQuaternion& quaternion)
{
#if defined(GX_USE_SSE2)
    __m128 q = _mm_loadu_ps( &quaternion._x );
    #define _SHF_YXX _MM_SHUFFLE(3,0,0,1)
    #define _SHF_ZZY _MM_SHUFFLE(3,1,2,2)
 
    #define _SHF_XYX _MM_SHUFFLE(3,0,1,0)
    #define _SHF_YZZ _MM_SHUFFLE(3,2,2,1)
    #define _SHF_WWW _MM_SHUFFLE(3,3,3,3)
    #define _SHF_ZXY _MM_SHUFFLE(3,1,0,2)
 
    #define _SHF_XXY _MM_SHUFFLE(3,1,0,0)
    #define _SHF_ZYZ _MM_SHUFFLE(3,2,1,2)
    #define _SHF_YZX _MM_SHUFFLE(3,0,2,1)
 
    __m128 v0,v1,v2,v3;
    __m128 r0,r1,r2;
    __m128 t0,t1,t2;
 
    __m128 c0 = _mm_set_ps(+0.0f,+1.0f,+1.0f,+1.0f);
    __m128 c1 = _mm_set_ps(+0.0f,-2.0f,-2.0f,-2.0f);
    __m128 c2 = _mm_set_ps(+0.0f,+2.0f,+2.0f,+2.0f);
 
    v0 = _mm_shuffle_ps(q, q, _SHF_YXX);    
    v1 = _mm_shuffle_ps(q, q, _SHF_ZZY);
 
    t0 = _mm_add_ps( _mm_mul_ps( v0, v0 ), _mm_mul_ps( v1, v1 ) );
    t0 = _mm_add_ps( c0, _mm_mul_ps( c1, t0 ) );
 
    v0 = _mm_shuffle_ps(q, q, _SHF_XYX);    
    v1 = _mm_shuffle_ps(q, q, _SHF_YZZ);
    v2 = _mm_shuffle_ps(q, q, _SHF_WWW);    
    v3 = _mm_shuffle_ps(q, q, _SHF_ZXY);
 
    v0 = _mm_mul_ps( v0, v1 );
    v1 = _mm_mul_ps( v2, v3 );
    t1 = _mm_mul_ps( c2, _mm_add_ps( v0, v1 ) );
 
    v0 = _mm_shuffle_ps(v0, v0, _MM_SHUFFLE(3,1,0,2) ); 
    v1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3,1,0,2) );
 
    t2 = _mm_mul_ps( c2, _mm_sub_ps( v0, v1 ) );
 
    r0 = _mm_unpacklo_ps( _mm_unpacklo_ps( t0, t2 ), _mm_unpacklo_ps( t1, _mm_setzero_ps() ) );
    r1 = _mm_unpackhi_ps( _mm_unpacklo_ps( t2, t1 ), _mm_unpacklo_ps( t0, _mm_setzero_ps() ) );
    r2 = _mm_unpacklo_ps( _mm_unpackhi_ps( t1, t0 ), _mm_unpackhi_ps( t2, _mm_setzero_ps() ) );
 
    __m128 s = _mm_loadu_ps( &scale._x );
 
    _r[0] = _mm_mul_ps( SPLATX(s), r0 );
    _r[1] = _mm_mul_ps( SPLATY(s), r1 );
    _r[2] = _mm_mul_ps( SPLATZ(s), r2 );
    _r[3] = _mm_setzero_ps();
#else //GX_USE_SSE2
    setScale(scale);
    mulQuaternionBack(quaternion);
#endif // !GX_USE_SSE2
}
 
//---------------------------------------------------------------------------
// 平行移動乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulTranslate(const GxVector3& vector)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrixAffine matrix;
    matrix.setTranslate(vector);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[3][0] += vector._x;
    _m[3][1] += vector._y;
    _m[3][2] += vector._z;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 平行移動乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulTranslate(f32 x, f32 y, f32 z)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrixAffine matrix;
    matrix.setTranslate(x, y, z);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[3][0] += x;
    _m[3][1] += y;
    _m[3][2] += z;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スケール乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulScale(const GxVector3& vector)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrixAffine matrix;
    matrix.setScale(vector);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[0][0] = _m[0][0] * vector._x;
    _m[0][1] = _m[0][1] * vector._y;
    _m[0][2] = _m[0][2] * vector._z;
    
    _m[1][0] = _m[1][0] * vector._x;
    _m[1][1] = _m[1][1] * vector._y;
    _m[1][2] = _m[1][2] * vector._z;
    
    _m[2][0] = _m[2][0] * vector._x;
    _m[2][1] = _m[2][1] * vector._y;
    _m[2][2] = _m[2][2] * vector._z;
    
    _m[3][0] = _m[3][0] * vector._x;
    _m[3][1] = _m[3][1] * vector._y;
    _m[3][2] = _m[3][2] * vector._z;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スケール乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::mulScale(f32 x, f32 y, f32 z)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrixAffine matrix;
    matrix.setScale(x, y, z);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[0][0] = _m[0][0] * x;
    _m[0][1] = _m[0][1] * y;
    _m[0][2] = _m[0][2] * z;
    
    _m[1][0] = _m[1][0] * x;
    _m[1][1] = _m[1][1] * y;
    _m[1][2] = _m[1][2] * z;
    
    _m[2][0] = _m[2][0] * x;
    _m[2][1] = _m[2][1] * y;
    _m[2][2] = _m[2][2] * z;
    
    _m[3][0] = _m[3][0] * x;
    _m[3][1] = _m[3][1] * y;
    _m[3][2] = _m[3][2] * z;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 逆行列にする
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::inverse(void)
{
    return getInverse(*this, *this);
}
 
//---------------------------------------------------------------------------
// 転置する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrixAffine& GxMatrixAffine::transpose(void)
{
    const auto m00 = _m[0][0];
    const auto m01 = _m[1][0];
    const auto m02 = _m[2][0];
                    
    const auto m10 = _m[0][1];
    const auto m11 = _m[1][1];
    const auto m12 = _m[2][1];
                    
    const auto m20 = _m[0][2];
    const auto m21 = _m[1][2];
    const auto m22 = _m[2][2];
 
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
               
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
               
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
 
    return *this;
}
 
//===========================================================================
// GxMatrix44
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44::GxMatrix44(INIT initType)
{
    switch(initType)
    {
    case INIT::ZERO:
        setZero();
        break;
    case INIT::IDENTITY:
        setIdentity();
        break;
    case INIT::NONE:
    default:
        break;
    }
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44::GxMatrix44(const GxQuaternion& quaternion, const GxVector3& position)
{
    setRotate(quaternion);
    setPosition(position);
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44::GxMatrix44(const GxQuaternion& quaternion)
{
    setRotate(quaternion);
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44::GxMatrix44(const GxVector3& position)
{
    setTranslate(position);
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44::GxMatrix44(   f32 m00, f32 m01, f32 m02, f32 m03,
                                    f32 m10, f32 m11, f32 m12, f32 m13,
                                    f32 m20, f32 m21, f32 m22, f32 m23,
                                    f32 m30, f32 m31, f32 m32, f32 m33)
{
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
    _m[0][3] = m03;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
    _m[1][3] = m13;
 
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
    _m[2][3] = m23;
    
    _m[3][0] = m30;
    _m[3][1] = m31;
    _m[3][2] = m32;
    _m[3][3] = m33;
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44::GxMatrix44(const GxMatrixAffine& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
    _m[0][3] = 0.0f;
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
    _m[1][3] = 0.0f;
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
    _m[2][3] = 0.0f;
 
    _m[3][0] = matrix._m[3][0];
    _m[3][1] = matrix._m[3][1];
    _m[3][2] = matrix._m[3][2];
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44::GxMatrix44(const GxMatrix44& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
    _m[0][3] = matrix._m[0][3];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
    _m[1][3] = matrix._m[1][3];
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
    _m[2][3] = matrix._m[2][3];
 
    _m[3][0] = matrix._m[3][0];
    _m[3][1] = matrix._m[3][1];
    _m[3][2] = matrix._m[3][2];
    _m[3][3] = matrix._m[3][3];
}
 
//---------------------------------------------------------------------------
// 初期化
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::initialize(const GxQuaternion& quaternion, const GxVector3& position)
{
    setRotate(quaternion);
    setPosition(position);
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix44& GxMatrix44::operator = (const GxMatrix44& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
    _m[0][3] = matrix._m[0][3];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
    _m[1][3] = matrix._m[1][3];
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
    _m[2][3] = matrix._m[2][3];
 
    _m[3][0] = matrix._m[3][0];
    _m[3][1] = matrix._m[3][1];
    _m[3][2] = matrix._m[3][2];
    _m[3][3] = matrix._m[3][3];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix44& GxMatrix44::operator *= (f32 scalar)
{
    mulScalar(scalar);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix44& GxMatrix44::operator /= (f32 scalar)
{
    divScalar(scalar);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix44& GxMatrix44::operator += (const GxMatrix44& matrix)
{
    addMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix44& GxMatrix44::operator *= (const GxMatrix44& matrix)
{
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44 operator * (const GxMatrix44& matrix, f32 scalar)
{
    GxMatrix44 result; // empty constructor
    return GxMatrix44::getMulScalar(result, matrix, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44 operator / (const GxMatrix44& matrix, f32 scalar)
{
    GxMatrix44 result; // empty constructor
    return GxMatrix44::getDivScalar(result, matrix, scalar);
}
 
//---------------------------------------------------------------------------
// 行列加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44 operator + (const GxMatrix44& matrix0, const GxMatrix44& matrix1)
{
    GxMatrix44 result; // empty constructor
    return GxMatrix44::getAddMatrix(result, matrix0, matrix1);
}
 
//---------------------------------------------------------------------------
// 行列乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44 operator * (const GxMatrix44& matrix0, const GxMatrix44& matrix1)
{
    GxMatrix44 result; // empty constructor
    return GxMatrix44::getMulMatrix(result, matrix0, matrix1);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrix44::operator == (const GxMatrix44& matrix)
{
    return ((_m[0][0] == matrix._m[0][0]) && (_m[0][1] == matrix._m[0][1]) && (_m[0][2] == matrix._m[0][2]) && (_m[0][3] == matrix._m[0][3]))
        && ((_m[1][0] == matrix._m[1][0]) && (_m[1][1] == matrix._m[1][1]) && (_m[1][2] == matrix._m[1][2]) && (_m[1][3] == matrix._m[1][3]))
        && ((_m[2][0] == matrix._m[2][0]) && (_m[2][1] == matrix._m[2][1]) && (_m[2][2] == matrix._m[2][2]) && (_m[2][3] == matrix._m[2][3]))
        && ((_m[3][0] == matrix._m[3][0]) && (_m[3][1] == matrix._m[3][1]) && (_m[3][2] == matrix._m[3][2]) && (_m[3][3] == matrix._m[3][3]));
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxMatrix44::operator != (const GxMatrix44& matrix)
{
    return !(*this == matrix);
}
 
//---------------------------------------------------------------------------
// 単位行列に設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setIdentity(void)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
    _m[0][3] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
    _m[1][3] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
    _m[2][3] = 0.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定(X軸回転)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setRotateX(f32 sinValue, f32 cosValue)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
    _m[0][3] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = cosValue;
    _m[1][2] = sinValue;
    _m[1][3] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] =-sinValue;
    _m[2][2] = cosValue;
    _m[2][3] = 0.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定(Y軸回転)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setRotateY(f32 sinValue, f32 cosValue)
{
    _m[0][0] = cosValue;
    _m[0][1] = 0.0f;
    _m[0][2] =-sinValue;
    _m[0][3] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
    _m[1][3] = 0.0f;
 
    _m[2][0] = sinValue;
    _m[2][1] = 0.0f;
    _m[2][2] = cosValue;
    _m[2][3] = 0.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定(Z軸回転)
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setRotateZ(f32 sinValue, f32 cosValue)
{
    _m[0][0] = cosValue;
    _m[0][1] = sinValue;
    _m[0][2] = 0.0f;
    _m[0][3] = 0.0f;
 
    _m[1][0] =-sinValue;
    _m[1][1] = cosValue;
    _m[1][2] = 0.0f;
    _m[1][3] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
    _m[2][3] = 0.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// XYZ軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrix44::getRotateXYZ(void) const
{
    // TODO:
    GxVector3   vector;
 
    if( _m[0][2] < 1.0f )
    {
        if( _m[0][2] > -1.0f )
        {
            vector._x = -GxMath::getATan2(-_m[1][2], _m[2][2]);
            vector._y = -GxMath::getASin(_m[0][2]);
            vector._z = -GxMath::getATan2(-_m[0][1], _m[0][0]);
        }
        else
        {
            vector._x = GxMath::getATan2(_m[1][0], _m[1][1]);
            vector._y = PI * 0.5f;
            vector._z = 0.0f;
        }
    }
    else
    {
        vector._x = -GxMath::getATan2(_m[1][0], _m[1][1]);
        vector._y = -PI * 0.5f;
        vector._z = 0.0f;
    }
    return vector;
}
 
//---------------------------------------------------------------------------
// XZY軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrix44::getRotateXZY(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[0][1] < 1.0f )
    {
        if( _m[0][1] > -1.0f )
        {
            vector._x = -GxMath::getATan2(_m[2][1], _m[1][1]);
            vector._z = -GxMath::getASin(-_m[0][1]);
            vector._y = -GxMath::getATan2(_m[0][2], _m[0][0]);
        }
        else
        {
            vector._x = -GxMath::getATan2(_m[2][0], _m[2][2]);
            vector._z = -PI * 0.5f;
            vector._y = 0.0f;
        }
    }
    else
    {
        vector._x = -GxMath::getATan2(-_m[2][0], _m[2][2]);
        vector._z = PI * 0.5f;
        vector._y = 0.0f;
    }
    return vector;
}
 
//---------------------------------------------------------------------------
// YXZ軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrix44::getRotateYXZ(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[1][2] < 1.0f )
    {
        if( _m[1][2] > -1.0f )
        {
            vector._y = -GxMath::getATan2(_m[0][2], _m[2][2]);
            vector._x = -GxMath::getASin(-_m[1][2]);
            vector._z = -GxMath::getATan2(_m[1][0], _m[1][1]);
        }
        else
        {
            vector._y = -GxMath::getATan2(_m[0][1], _m[0][0]);
            vector._x = -PI * 0.5f;
            vector._z = 0.0f;
        }
    }
    else
    {
        vector._y = -GxMath::getATan2(-_m[0][1], _m[0][0]);
        vector._x = PI * 0.5f;
        vector._z = 0.0f;
    }
    return vector;
}
 
//---------------------------------------------------------------------------
// YZX軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrix44::getRotateYZX(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[1][0] < 1.0f )
    {
        if( _m[1][0] > -1.0f )
        {
            vector._y = -GxMath::getATan2(-_m[2][0], _m[0][0]);
            vector._z = -GxMath::getASin(_m[1][0]);
            vector._x = -GxMath::getATan2(-_m[1][2], _m[1][1]);
        }
        else
        {
            vector._y = GxMath::getATan2(_m[2][1], _m[2][2]);
            vector._z = PI * 0.5f;
            vector._x = 0.0f;
        }
    }
    else
    {
        vector._y = -GxMath::getATan2(_m[2][1], _m[2][2]);
        vector._z = -PI * 0.5f;
        vector._x = 0.0f;
    }
    return vector;
}
 
//---------------------------------------------------------------------------
// ZXY軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrix44::getRotateZXY(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[2][1] < 1.0f )
    {
        if( _m[2][1] > -1.0f )
        {
            vector._z = -GxMath::getATan2(-_m[0][1], _m[1][1]);
            vector._x = -GxMath::getASin(_m[2][1]);
            vector._y = -GxMath::getATan2(-_m[2][0], _m[2][2]);
        }
        else
        {
            vector._z = GxMath::getATan2(_m[2][0], _m[0][0]);
            vector._x = PI * 0.5f;
            vector._y = 0.0f;
        }
    }
    else
    {
        vector._z = -GxMath::getATan2(_m[0][2], _m[0][0]);
        vector._x = -PI * 0.5f;
        vector._y = 0.0f;
    }
 
    return vector;
}
 
//---------------------------------------------------------------------------
// ZYX軸回転角を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxVector3 GxMatrix44::getRotateZYX(void) const
{
    // TODO:
    GxVector3   vector;
    if( _m[2][0] < 1.0f )
    {
        if( _m[2][0] > -1.0f )
        {
            vector._z = -GxMath::getATan2(_m[1][0], _m[0][0]);
            vector._y = -GxMath::getASin(-_m[2][0]);
            vector._x = -GxMath::getATan2(_m[2][1], _m[2][2]);
        }
        else
        {
            vector._z = GxMath::getATan2(_m[0][1], _m[0][2]);
            vector._y = -PI * 0.5f;
            vector._x = 0.0f;
        }
    }
    else
    {
        vector._z = -GxMath::getATan2(-_m[0][1], -_m[0][2]);
        vector._y = PI * 0.5f;
        vector._x = 0.0f;
    }
    
    return vector;
}
 
//---------------------------------------------------------------------------
// 平行移動行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setTranslate(const GxVector3& vector)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
    _m[0][3] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
    _m[1][3] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
    _m[2][3] = 0.0f;
 
    _m[3][0] = vector._x;
    _m[3][1] = vector._y;
    _m[3][2] = vector._z;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 平行移動行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setTranslate(f32 x, f32 y, f32 z)
{
    _m[0][0] = 1.0f;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
    _m[0][3] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = 1.0f;
    _m[1][2] = 0.0f;
    _m[1][3] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = 1.0f;
    _m[2][3] = 0.0f;
 
    _m[3][0] = x;
    _m[3][1] = y;
    _m[3][2] = z;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 平行移動量のみを設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setPosition(const GxVector3& position)
{
    _m[3][0] = position._x;
    _m[3][1] = position._y;
    _m[3][2] = position._z;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 平行移動量のみを設定
//
GX_FORCE_INLINE void GxMatrix44::setPosition(f32 x, f32 y, f32 z)
{
    _m[3][0] = x;
    _m[3][1] = y;
    _m[3][2] = z;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// スケール行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setScale(const GxVector3& vector)
{
    _m[0][0] = vector._x;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
    _m[0][3] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = vector._y;
    _m[1][2] = 0.0f;
    _m[1][3] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = vector._z;
    _m[2][3] = 0.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// スケール行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setScale(f32 x, f32 y, f32 z)
{
    _m[0][0] = x;
    _m[0][1] = 0.0f;
    _m[0][2] = 0.0f;
    _m[0][3] = 0.0f;
 
    _m[1][0] = 0.0f;
    _m[1][1] = y;
    _m[1][2] = 0.0f;
    _m[1][3] = 0.0f;
 
    _m[2][0] = 0.0f;
    _m[2][1] = 0.0f;
    _m[2][2] = z;
    _m[2][3] = 0.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定
//
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setRotateAxis(const GxVector3& vector, f32 radian)
{
    auto sinValue = GxMath::getSin(radian);
    auto cosValue = GxMath::getCos(radian);
 
    _m[0][0] = cosValue + vector._x * vector._x * (1.0f - cosValue);
    _m[0][1] = vector._x * vector._y * (1.0f - cosValue) + vector._z * sinValue;
    _m[0][2] = vector._x * vector._z * (1.0f - cosValue) - vector._y * sinValue;
    _m[0][3] = 0.0f;
 
    _m[1][0] = vector._x * vector._y * (1.0f - cosValue) - vector._z * sinValue;
    _m[1][1] = cosValue + vector._y * vector._y * (1.0f - cosValue);
    _m[1][2] = vector._y * vector._z * (1.0f - cosValue) + vector._x * sinValue;
    _m[1][3] = 0.0f;
 
    _m[2][0] = vector._x * vector._z * (1.0f - cosValue) + vector._y * sinValue;
    _m[2][1] = vector._y * vector._z * (1.0f - cosValue) - vector._x * sinValue;
    _m[2][2] = cosValue + vector._z * vector._z * (1.0f - cosValue);
    _m[2][3] = 0.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 回転行列を設定
//
//---------------------------------------------------------------------------
GX_INLINE void GxMatrix44::setRotate(const GxQuaternion& quaternion)
{
    _m[0][0] = 1.0f - 2.0f * (quaternion._y * quaternion._y + quaternion._z * quaternion._z);
    _m[0][1] = 2.0f * (quaternion._x * quaternion._y + quaternion._w * quaternion._z);
    _m[0][2] = 2.0f * (quaternion._x * quaternion._z - quaternion._w * quaternion._y);
    _m[0][3] = 0.0f;
 
    _m[1][0] = 2.0f * (quaternion._x * quaternion._y - quaternion._w * quaternion._z);
    _m[1][1] = 1.0f - 2.0f * (quaternion._x * quaternion._x + quaternion._z * quaternion._z);
    _m[1][2] = 2.0f * (quaternion._y * quaternion._z + quaternion._w * quaternion._x);
    _m[1][3] = 0.0f;
 
    _m[2][0] = 2.0f * (quaternion._x * quaternion._z + quaternion._w * quaternion._y);
    _m[2][1] = 2.0f * (quaternion._y * quaternion._z - quaternion._w * quaternion._x);
    _m[2][2] = 1.0f - 2.0f * (quaternion._x * quaternion._x + quaternion._y * quaternion._y);
    _m[2][3] = 0.0f;
 
    _m[3][0] = 0.0f;
    _m[3][1] = 0.0f;
    _m[3][2] = 0.0f;
    _m[3][3] = 1.0f;
}
 
//---------------------------------------------------------------------------
// 行を取得
//---------------------------------------------------------------------------
const GxVector4& GxMatrix44::getRow(u32 row) const
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    return *reinterpret_cast<const GxVector4*>(&_m[row][0]);
}
 
//---------------------------------------------------------------------------
// 行を設定
//---------------------------------------------------------------------------
void GxMatrix44::setRow(u32 row, const GxVector4& vector)
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    _m[row][0] = vector._x;
    _m[row][1] = vector._y;
    _m[row][2] = vector._z;
    _m[row][3] = vector._w;
}
 
//---------------------------------------------------------------------------
// 列を取得
//---------------------------------------------------------------------------
GxVector4 GxMatrix44::getColumn(u32 column) const
{
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    return GxVector4(_m[0][column], _m[1][column], _m[2][column], _m[3][column]);
}
 
//---------------------------------------------------------------------------
// 列を設定
//
//---------------------------------------------------------------------------
void GxMatrix44::setColumn(u32 column, const GxVector4& vector)
{
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    _m[0][column] = vector._x;
    _m[1][column] = vector._y;
    _m[2][column] = vector._z;
    _m[3][column] = vector._w;
}
 
//---------------------------------------------------------------------------
// 値を取得
//---------------------------------------------------------------------------
f32 GxMatrix44::getValue(u32 row, u32 column) const
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 値を設定
//
//---------------------------------------------------------------------------
void GxMatrix44::setValue(u32 row, u32 column, f32 value)
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    _m[row][column] = value;
}
 
//---------------------------------------------------------------------------
// 参照を取得
//---------------------------------------------------------------------------
f32& GxMatrix44::getReference(u32 row, u32 column)
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 参照を取得
//---------------------------------------------------------------------------
const f32& GxMatrix44::getReference(u32 row, u32 column) const
{
    GX_ASSERT(row < 4, "指定された行数が大きすぎます(%d)", row);
    GX_ASSERT(column < 4, "指定された列数が大きすぎます(%d)", column);
    return _m[row][column];
}
 
//---------------------------------------------------------------------------
// 行列式の値を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxMatrix44::getDeterminant(void) const
{
    return _m[0][0] * GxMatrix33(_m[1][1], _m[1][2], _m[1][3], _m[2][1], _m[2][2], _m[2][3], _m[3][1], _m[3][2], _m[3][3]).getDeterminant()
         - _m[0][1] * GxMatrix33(_m[1][0], _m[1][2], _m[1][3], _m[2][0], _m[2][2], _m[2][3], _m[3][0], _m[3][2], _m[3][3]).getDeterminant()
         + _m[0][2] * GxMatrix33(_m[1][0], _m[1][1], _m[1][3], _m[2][0], _m[2][1], _m[2][3], _m[3][0], _m[3][1], _m[3][3]).getDeterminant()
         - _m[0][3] * GxMatrix33(_m[1][0], _m[1][1], _m[1][2], _m[2][0], _m[2][1], _m[2][2], _m[3][0], _m[3][1], _m[3][2]).getDeterminant();
}
 
//---------------------------------------------------------------------------
// 逆行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix44 GxMatrix44::getInverse(void) const
{
    GxMatrix44 result; // empty constructor
    return GxMatrix44::getInverse(result, *this);
}
 
//---------------------------------------------------------------------------
// 転置行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix44 GxMatrix44::getTranspose(void) const
{
    return GxMatrix44(  _m[0][0], _m[1][0], _m[2][0], _m[3][0],
                        _m[0][1], _m[1][1], _m[2][1], _m[3][1],
                        _m[0][2], _m[1][2], _m[2][2], _m[3][2],
                        _m[0][3], _m[1][3], _m[2][3], _m[3][3]);
}
 
//---------------------------------------------------------------------------
// 位置以外の各軸を正規化したものを取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxMatrix44 GxMatrix44::getNormalizeAxes(void) const
{
    GxMatrix44 matrix(getPosition());
 
    GxVector3 x(GxVector3(_m[0][0], _m[0][1], _m[0][2]).getNormalizeEx());
    GxVector3 y(GxVector3(_m[1][0], _m[1][1], _m[1][2]).getNormalizeEx());
    GxVector3 z(GxVector3(_m[2][0], _m[2][1], _m[2][2]).getNormalizeEx());
 
    matrix._m[0][0] = x._x;
    matrix._m[0][1] = x._y;
    matrix._m[0][2] = x._z;
    matrix._m[0][3] = 0.0f;
 
    matrix._m[1][0] = y._x;
    matrix._m[1][1] = y._y;
    matrix._m[1][2] = y._z;
    matrix._m[1][3] = 0.0f;
 
    matrix._m[2][0] = z._x;
    matrix._m[2][1] = z._y;
    matrix._m[2][2] = z._z;
    matrix._m[2][3] = 0.0f;
 
    return matrix;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::getMulScalar(GxMatrix44& dst, const GxMatrix44& matrix, f32 scalar)
{
    dst._m[0][0] = matrix._m[0][0] * scalar;
    dst._m[0][1] = matrix._m[0][1] * scalar;
    dst._m[0][2] = matrix._m[0][2] * scalar;
    dst._m[0][3] = matrix._m[0][3] * scalar;
 
    dst._m[1][0] = matrix._m[1][0] * scalar;
    dst._m[1][1] = matrix._m[1][1] * scalar;
    dst._m[1][2] = matrix._m[1][2] * scalar;
    dst._m[1][3] = matrix._m[1][3] * scalar;
 
    dst._m[2][0] = matrix._m[2][0] * scalar;
    dst._m[2][1] = matrix._m[2][1] * scalar;
    dst._m[2][2] = matrix._m[2][2] * scalar;
    dst._m[2][3] = matrix._m[2][3] * scalar;
 
    dst._m[3][0] = matrix._m[3][0] * scalar;
    dst._m[3][1] = matrix._m[3][1] * scalar;
    dst._m[3][2] = matrix._m[3][2] * scalar;
    dst._m[3][3] = matrix._m[3][3] * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::getDivScalar(GxMatrix44& dst, const GxMatrix44& matrix, f32 scalar)
{
    auto inverseScalar = 1.0f / scalar;
 
    dst._m[0][0] = matrix._m[0][0] * inverseScalar;
    dst._m[0][1] = matrix._m[0][1] * inverseScalar;
    dst._m[0][2] = matrix._m[0][2] * inverseScalar;
    dst._m[0][3] = matrix._m[0][3] * inverseScalar;
 
    dst._m[1][0] = matrix._m[1][0] * inverseScalar;
    dst._m[1][1] = matrix._m[1][1] * inverseScalar;
    dst._m[1][2] = matrix._m[1][2] * inverseScalar;
    dst._m[1][3] = matrix._m[1][3] * inverseScalar;
 
    dst._m[2][0] = matrix._m[2][0] * inverseScalar;
    dst._m[2][1] = matrix._m[2][1] * inverseScalar;
    dst._m[2][2] = matrix._m[2][2] * inverseScalar;
    dst._m[2][3] = matrix._m[2][3] * inverseScalar;
 
    dst._m[3][0] = matrix._m[3][0] * inverseScalar;
    dst._m[3][1] = matrix._m[3][1] * inverseScalar;
    dst._m[3][2] = matrix._m[3][2] * inverseScalar;
    dst._m[3][3] = matrix._m[3][3] * inverseScalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::getAddMatrix(GxMatrix44& dst, const GxMatrix44& matrix0, const GxMatrix44& matrix1)
{
    dst._m[0][0] = matrix0._m[0][0] + matrix1._m[0][0];
    dst._m[0][1] = matrix0._m[0][1] + matrix1._m[0][1];
    dst._m[0][2] = matrix0._m[0][2] + matrix1._m[0][2];
    dst._m[0][3] = matrix0._m[0][3] + matrix1._m[0][3];
 
    dst._m[1][0] = matrix0._m[1][0] + matrix1._m[1][0];
    dst._m[1][1] = matrix0._m[1][1] + matrix1._m[1][1];
    dst._m[1][2] = matrix0._m[1][2] + matrix1._m[1][2];
    dst._m[1][3] = matrix0._m[1][3] + matrix1._m[1][3];
 
    dst._m[2][0] = matrix0._m[2][0] + matrix1._m[2][0];
    dst._m[2][1] = matrix0._m[2][1] + matrix1._m[2][1];
    dst._m[2][2] = matrix0._m[2][2] + matrix1._m[2][2];
    dst._m[2][3] = matrix0._m[2][3] + matrix1._m[2][3];
 
    dst._m[3][0] = matrix0._m[3][0] + matrix1._m[3][0];
    dst._m[3][1] = matrix0._m[3][1] + matrix1._m[3][1];
    dst._m[3][2] = matrix0._m[3][2] + matrix1._m[3][2];
    dst._m[3][3] = matrix0._m[3][3] + matrix1._m[3][3];
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 行列乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::getMulMatrix(GxMatrix44& dst, const GxMatrix44& matrix0, const GxMatrix44& matrix1)
{
#if defined(GX_USE_SSE2)
    for(s32 i=0; i < 4; ++i)
    {
        __m128 curRow = matrix0._r[i];
 
        __m128 mx = _mm_shuffle_ps(curRow, curRow, _MM_SHUFFLE(0,0,0,0));
        __m128 my = _mm_shuffle_ps(curRow, curRow, _MM_SHUFFLE(1,1,1,1));
        __m128 mz = _mm_shuffle_ps(curRow, curRow, _MM_SHUFFLE(2,2,2,2));
        __m128 mw = _mm_shuffle_ps(curRow, curRow, _MM_SHUFFLE(3,3,3,3));
 
        mx = _mm_mul_ps(mx, matrix1._r[0]);
        my = _mm_mul_ps(my, matrix1._r[1]);
        mz = _mm_mul_ps(mz, matrix1._r[2]);
        mw = _mm_mul_ps(mw, matrix1._r[3]);
 
        dst._r[i] = _mm_add_ps(_mm_add_ps(mx,my), _mm_add_ps(mz,mw));
    }
#else //GX_USE_SSE2
    // 入力と出力が同じ行列だった場合を考慮して、一時変数で計算する
    const auto m00 = matrix0._m[0][0] * matrix1._m[0][0] + matrix0._m[0][1] * matrix1._m[1][0] + matrix0._m[0][2] * matrix1._m[2][0] + matrix0._m[0][3] * matrix1._m[3][0];
    const auto m01 = matrix0._m[0][0] * matrix1._m[0][1] + matrix0._m[0][1] * matrix1._m[1][1] + matrix0._m[0][2] * matrix1._m[2][1] + matrix0._m[0][3] * matrix1._m[3][1];
    const auto m02 = matrix0._m[0][0] * matrix1._m[0][2] + matrix0._m[0][1] * matrix1._m[1][2] + matrix0._m[0][2] * matrix1._m[2][2] + matrix0._m[0][3] * matrix1._m[3][2];
    const auto m03 = matrix0._m[0][0] * matrix1._m[0][3] + matrix0._m[0][1] * matrix1._m[1][3] + matrix0._m[0][2] * matrix1._m[2][3] + matrix0._m[0][3] * matrix1._m[3][3];
 
    const auto m10 = matrix0._m[1][0] * matrix1._m[0][0] + matrix0._m[1][1] * matrix1._m[1][0] + matrix0._m[1][2] * matrix1._m[2][0] + matrix0._m[1][3] * matrix1._m[3][0];
    const auto m11 = matrix0._m[1][0] * matrix1._m[0][1] + matrix0._m[1][1] * matrix1._m[1][1] + matrix0._m[1][2] * matrix1._m[2][1] + matrix0._m[1][3] * matrix1._m[3][1];
    const auto m12 = matrix0._m[1][0] * matrix1._m[0][2] + matrix0._m[1][1] * matrix1._m[1][2] + matrix0._m[1][2] * matrix1._m[2][2] + matrix0._m[1][3] * matrix1._m[3][2];
    const auto m13 = matrix0._m[1][0] * matrix1._m[0][3] + matrix0._m[1][1] * matrix1._m[1][3] + matrix0._m[1][2] * matrix1._m[2][3] + matrix0._m[1][3] * matrix1._m[3][3];
 
    const auto m20 = matrix0._m[2][0] * matrix1._m[0][0] + matrix0._m[2][1] * matrix1._m[1][0] + matrix0._m[2][2] * matrix1._m[2][0] + matrix0._m[2][3] * matrix1._m[3][0];
    const auto m21 = matrix0._m[2][0] * matrix1._m[0][1] + matrix0._m[2][1] * matrix1._m[1][1] + matrix0._m[2][2] * matrix1._m[2][1] + matrix0._m[2][3] * matrix1._m[3][1];
    const auto m22 = matrix0._m[2][0] * matrix1._m[0][2] + matrix0._m[2][1] * matrix1._m[1][2] + matrix0._m[2][2] * matrix1._m[2][2] + matrix0._m[2][3] * matrix1._m[3][2];
    const auto m23 = matrix0._m[2][0] * matrix1._m[0][3] + matrix0._m[2][1] * matrix1._m[1][3] + matrix0._m[2][2] * matrix1._m[2][3] + matrix0._m[2][3] * matrix1._m[3][3];
 
    const auto m30 = matrix0._m[3][0] * matrix1._m[0][0] + matrix0._m[3][1] * matrix1._m[1][0] + matrix0._m[3][2] * matrix1._m[2][0] + matrix0._m[3][3] * matrix1._m[3][0];
    const auto m31 = matrix0._m[3][0] * matrix1._m[0][1] + matrix0._m[3][1] * matrix1._m[1][1] + matrix0._m[3][2] * matrix1._m[2][1] + matrix0._m[3][3] * matrix1._m[3][1];
    const auto m32 = matrix0._m[3][0] * matrix1._m[0][2] + matrix0._m[3][1] * matrix1._m[1][2] + matrix0._m[3][2] * matrix1._m[2][2] + matrix0._m[3][3] * matrix1._m[3][2];
    const auto m33 = matrix0._m[3][0] * matrix1._m[0][3] + matrix0._m[3][1] * matrix1._m[1][3] + matrix0._m[3][2] * matrix1._m[2][3] + matrix0._m[3][3] * matrix1._m[3][3];
 
    dst._m[0][0] = m00;
    dst._m[0][1] = m01;
    dst._m[0][2] = m02;
    dst._m[0][3] = m03;
 
    dst._m[1][0] = m10;
    dst._m[1][1] = m11;
    dst._m[1][2] = m12;
    dst._m[1][3] = m13;
 
    dst._m[2][0] = m20;
    dst._m[2][1] = m21;
    dst._m[2][2] = m22;
    dst._m[2][3] = m23;
 
    dst._m[3][0] = m30;
    dst._m[3][1] = m31;
    dst._m[3][2] = m32;
    dst._m[3][3] = m33;
#endif // !GX_USE_SSE2
    return dst;
}
 
//---------------------------------------------------------------------------
// 逆行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::getInverse(GxMatrix44& dst, const GxMatrix44& matrix)
{
    const auto m00 =  GxMatrix33(matrix._m[1][1], matrix._m[1][2], matrix._m[1][3], matrix._m[2][1], matrix._m[2][2], matrix._m[2][3], matrix._m[3][1], matrix._m[3][2], matrix._m[3][3]).getDeterminant();
    const auto m01 = -GxMatrix33(matrix._m[0][1], matrix._m[0][2], matrix._m[0][3], matrix._m[2][1], matrix._m[2][2], matrix._m[2][3], matrix._m[3][1], matrix._m[3][2], matrix._m[3][3]).getDeterminant();
    const auto m02 =  GxMatrix33(matrix._m[0][1], matrix._m[0][2], matrix._m[0][3], matrix._m[1][1], matrix._m[1][2], matrix._m[1][3], matrix._m[3][1], matrix._m[3][2], matrix._m[3][3]).getDeterminant();
    const auto m03 = -GxMatrix33(matrix._m[0][1], matrix._m[0][2], matrix._m[0][3], matrix._m[1][1], matrix._m[1][2], matrix._m[1][3], matrix._m[2][1], matrix._m[2][2], matrix._m[2][3]).getDeterminant();
                                                                                                                                                                        
    const auto m10 = -GxMatrix33(matrix._m[1][0], matrix._m[1][2], matrix._m[1][3], matrix._m[2][0], matrix._m[2][2], matrix._m[2][3], matrix._m[3][0], matrix._m[3][2], matrix._m[3][3]).getDeterminant();
    const auto m11 =  GxMatrix33(matrix._m[0][0], matrix._m[0][2], matrix._m[0][3], matrix._m[2][0], matrix._m[2][2], matrix._m[2][3], matrix._m[3][0], matrix._m[3][2], matrix._m[3][3]).getDeterminant();
    const auto m12 = -GxMatrix33(matrix._m[0][0], matrix._m[0][2], matrix._m[0][3], matrix._m[1][0], matrix._m[1][2], matrix._m[1][3], matrix._m[3][0], matrix._m[3][2], matrix._m[3][3]).getDeterminant();
    const auto m13 =  GxMatrix33(matrix._m[0][0], matrix._m[0][2], matrix._m[0][3], matrix._m[1][0], matrix._m[1][2], matrix._m[1][3], matrix._m[2][0], matrix._m[2][2], matrix._m[2][3]).getDeterminant();
                                                                                                                                                                        
    const auto m20 =  GxMatrix33(matrix._m[1][0], matrix._m[1][1], matrix._m[1][3], matrix._m[2][0], matrix._m[2][1], matrix._m[2][3], matrix._m[3][0], matrix._m[3][1], matrix._m[3][3]).getDeterminant();
    const auto m21 = -GxMatrix33(matrix._m[0][0], matrix._m[0][1], matrix._m[0][3], matrix._m[2][0], matrix._m[2][1], matrix._m[2][3], matrix._m[3][0], matrix._m[3][1], matrix._m[3][3]).getDeterminant();
    const auto m22 =  GxMatrix33(matrix._m[0][0], matrix._m[0][1], matrix._m[0][3], matrix._m[1][0], matrix._m[1][1], matrix._m[1][3], matrix._m[3][0], matrix._m[3][1], matrix._m[3][3]).getDeterminant();
    const auto m23 = -GxMatrix33(matrix._m[0][0], matrix._m[0][1], matrix._m[0][3], matrix._m[1][0], matrix._m[1][1], matrix._m[1][3], matrix._m[2][0], matrix._m[2][1], matrix._m[2][3]).getDeterminant();
                                                                                                                                                                        
    const auto m30 = -GxMatrix33(matrix._m[1][0], matrix._m[1][1], matrix._m[1][2], matrix._m[2][0], matrix._m[2][1], matrix._m[2][2], matrix._m[3][0], matrix._m[3][1], matrix._m[3][2]).getDeterminant();
    const auto m31 =  GxMatrix33(matrix._m[0][0], matrix._m[0][1], matrix._m[0][2], matrix._m[2][0], matrix._m[2][1], matrix._m[2][2], matrix._m[3][0], matrix._m[3][1], matrix._m[3][2]).getDeterminant();
    const auto m32 = -GxMatrix33(matrix._m[0][0], matrix._m[0][1], matrix._m[0][2], matrix._m[1][0], matrix._m[1][1], matrix._m[1][2], matrix._m[3][0], matrix._m[3][1], matrix._m[3][2]).getDeterminant();
    const auto m33 =  GxMatrix33(matrix._m[0][0], matrix._m[0][1], matrix._m[0][2], matrix._m[1][0], matrix._m[1][1], matrix._m[1][2], matrix._m[2][0], matrix._m[2][1], matrix._m[2][2]).getDeterminant();
                                                                                                                                                                        
    const auto d = 1.0f / matrix.getDeterminant();
 
    dst._m[0][0] = m00 * d;
    dst._m[0][1] = m01 * d;
    dst._m[0][2] = m02 * d;
    dst._m[0][3] = m03 * d;
 
    dst._m[1][0] = m10 * d;
    dst._m[1][1] = m11 * d;
    dst._m[1][2] = m12 * d;
    dst._m[1][3] = m13 * d;
 
    dst._m[2][0] = m20 * d;
    dst._m[2][1] = m21 * d;
    dst._m[2][2] = m22 * d;
    dst._m[2][3] = m23 * d;
 
    dst._m[3][0] = m30 * d;
    dst._m[3][1] = m31 * d;
    dst._m[3][2] = m32 * d;
    dst._m[3][3] = m33 * d;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// 転置行列を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::getTranspose(GxMatrix44& dst, const GxMatrix44& matrix)
{
    const auto m00 = matrix._m[0][0];
    const auto m01 = matrix._m[1][0];
    const auto m02 = matrix._m[2][0];
    const auto m03 = matrix._m[3][0];
                    
    const auto m10 = matrix._m[0][1];
    const auto m11 = matrix._m[1][1];
    const auto m12 = matrix._m[2][1];
    const auto m13 = matrix._m[3][1];
                    
    const auto m20 = matrix._m[0][2];
    const auto m21 = matrix._m[1][2];
    const auto m22 = matrix._m[2][2];
    const auto m23 = matrix._m[3][2];
 
    const auto m30 = matrix._m[0][3];
    const auto m31 = matrix._m[1][3];
    const auto m32 = matrix._m[2][3];
    const auto m33 = matrix._m[3][3];
 
    dst._m[0][0] = m00;
    dst._m[0][1] = m01;
    dst._m[0][2] = m02;
    dst._m[0][3] = m03;
                   
    dst._m[1][0] = m10;
    dst._m[1][1] = m11;
    dst._m[1][2] = m12;
    dst._m[1][3] = m13;
                   
    dst._m[2][0] = m20;
    dst._m[2][1] = m21;
    dst._m[2][2] = m22;
    dst._m[2][3] = m23;
 
    dst._m[3][0] = m30;
    dst._m[3][1] = m31;
    dst._m[3][2] = m32;
    dst._m[3][3] = m33;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulScalar(f32 scalar)
{
    _m[0][0] *= scalar;
    _m[0][1] *= scalar;
    _m[0][2] *= scalar;
    _m[0][3] *= scalar;
 
    _m[1][0] *= scalar;
    _m[1][1] *= scalar;
    _m[1][2] *= scalar;
    _m[1][3] *= scalar;
 
    _m[2][0] *= scalar;
    _m[2][1] *= scalar;
    _m[2][2] *= scalar;
    _m[2][3] *= scalar;
 
    _m[3][0] *= scalar;
    _m[3][1] *= scalar;
    _m[3][2] *= scalar;
    _m[3][3] *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::divScalar(f32 scalar)
{
    auto inverseScalar = 1.0f / scalar;
 
    _m[0][0] *= inverseScalar;
    _m[0][1] *= inverseScalar;
    _m[0][2] *= inverseScalar;
    _m[0][3] *= inverseScalar;
 
    _m[1][0] *= inverseScalar;
    _m[1][1] *= inverseScalar;
    _m[1][2] *= inverseScalar;
    _m[1][3] *= inverseScalar;
 
    _m[2][0] *= inverseScalar;
    _m[2][1] *= inverseScalar;
    _m[2][2] *= inverseScalar;
    _m[2][3] *= inverseScalar;
 
    _m[3][0] *= inverseScalar;
    _m[3][1] *= inverseScalar;
    _m[3][2] *= inverseScalar;
    _m[3][3] *= inverseScalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::addMatrix(const GxMatrix44& matrix)
{
    _m[0][0] += matrix._m[0][0];
    _m[0][1] += matrix._m[0][1];
    _m[0][2] += matrix._m[0][2];
    _m[0][3] += matrix._m[0][3];
 
    _m[1][0] += matrix._m[1][0];
    _m[1][1] += matrix._m[1][1];
    _m[1][2] += matrix._m[1][2];
    _m[1][3] += matrix._m[1][3];
 
    _m[2][0] += matrix._m[2][0];
    _m[2][1] += matrix._m[2][1];
    _m[2][2] += matrix._m[2][2];
    _m[2][3] += matrix._m[2][3];
 
    _m[3][0] += matrix._m[3][0];
    _m[3][1] += matrix._m[3][1];
    _m[3][2] += matrix._m[3][2];
    _m[3][3] += matrix._m[3][3];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 行列乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulMatrix(const GxMatrix44& matrix)
{
    getMulMatrix( *this, *this, matrix );
    return *this;
}
 
//---------------------------------------------------------------------------
// X軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulRotateX(f32 radian)
{
    GxMatrix44 matrix;
    matrix.setRotateX(radian);
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// Y軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulRotateY(f32 radian)
{
    GxMatrix44 matrix;
    matrix.setRotateY(radian);
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// Z軸回転乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulRotateZ(f32 radian)
{
    GxMatrix44 matrix;
    matrix.setRotateZ(radian);
    mulMatrix(matrix);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオンによる回転乗算(前から乗算)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulQuaternionFront(const GxQuaternion& quaternion)
{
    GxMatrix44 matrix(quaternion);
    getMulMatrix(*this, matrix, *this);
 
    return *this;
}
 
//---------------------------------------------------------------------------
// クォータニオンによる回転乗算(後ろから乗算)
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulQuaternionBack(const GxQuaternion& quaternion)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix44 matrix(quaternion);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    const auto r00 = 1.0f - 2.0f * (quaternion._y * quaternion._y + quaternion._z * quaternion._z);
    const auto r01 = 2.0f * (quaternion._x * quaternion._y + quaternion._w * quaternion._z);
    const auto r02 = 2.0f * (quaternion._x * quaternion._z - quaternion._w * quaternion._y);
 
    const auto r10 = 2.0f * (quaternion._x * quaternion._y - quaternion._w * quaternion._z);
    const auto r11 = 1.0f - 2.0f * (quaternion._x * quaternion._x + quaternion._z * quaternion._z);
    const auto r12 = 2.0f * (quaternion._y * quaternion._z + quaternion._w * quaternion._x);
 
    const auto r20 = 2.0f * (quaternion._x * quaternion._z + quaternion._w * quaternion._y);
    const auto r21 = 2.0f * (quaternion._y * quaternion._z - quaternion._w * quaternion._x);
    const auto r22 = 1.0f - 2.0f * (quaternion._x * quaternion._x + quaternion._y * quaternion._y);
 
    const auto m00 = _m[0][0] * r00 + _m[0][1] * r10 + _m[0][2] * r20;
    const auto m01 = _m[0][0] * r01 + _m[0][1] * r11 + _m[0][2] * r21;
    const auto m02 = _m[0][0] * r02 + _m[0][1] * r12 + _m[0][2] * r22;
 
    const auto m10 = _m[1][0] * r00 + _m[1][1] * r10 + _m[1][2] * r20;
    const auto m11 = _m[1][0] * r01 + _m[1][1] * r11 + _m[1][2] * r21;
    const auto m12 = _m[1][0] * r02 + _m[1][1] * r12 + _m[1][2] * r22;
 
    const auto m20 = _m[2][0] * r00 + _m[2][1] * r10 + _m[2][2] * r20;
    const auto m21 = _m[2][0] * r01 + _m[2][1] * r11 + _m[2][2] * r21;
    const auto m22 = _m[2][0] * r02 + _m[2][1] * r12 + _m[2][2] * r22;
 
    const auto m30 = _m[3][0] * r00 + _m[3][1] * r10 + _m[3][2] * r20;
    const auto m31 = _m[3][0] * r01 + _m[3][1] * r11 + _m[3][2] * r21;
    const auto m32 = _m[3][0] * r02 + _m[3][1] * r12 + _m[3][2] * r22;
 
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
 
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
 
    _m[3][0] = m30;
    _m[3][1] = m31;
    _m[3][2] = m32;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 平行移動乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulTranslate(const GxVector3& vector)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix44 matrix;
    matrix.setTranslate(vector);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[0][0] += _m[0][3] * vector._x;
    _m[0][1] += _m[0][3] * vector._y;
    _m[0][2] += _m[0][3] * vector._z;
                           
    _m[1][0] += _m[1][3] * vector._x;
    _m[1][1] += _m[1][3] * vector._y;
    _m[1][2] += _m[1][3] * vector._z;
                           
    _m[2][0] += _m[2][3] * vector._x;
    _m[2][1] += _m[2][3] * vector._y;
    _m[2][2] += _m[2][3] * vector._z;
                           
    _m[3][0] += _m[3][3] * vector._x;
    _m[3][1] += _m[3][3] * vector._y;
    _m[3][2] += _m[3][3] * vector._z;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 平行移動乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulTranslate(f32 x, f32 y, f32 z)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix44 matrix;
    matrix.setTranslate(x, y, z);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[0][0] += _m[0][3] * x;
    _m[0][1] += _m[0][3] * y;
    _m[0][2] += _m[0][3] * z;
    
    _m[1][0] += _m[1][3] * x;
    _m[1][1] += _m[1][3] * y;
    _m[1][2] += _m[1][3] * z;
    
    _m[2][0] += _m[2][3] * x;
    _m[2][1] += _m[2][3] * y;
    _m[2][2] += _m[2][3] * z;
    
    _m[3][0] += _m[3][3] * x;
    _m[3][1] += _m[3][3] * y;
    _m[3][2] += _m[3][3] * z;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スケール乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulScale(const GxVector3& vector)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix44 matrix;
    matrix.setScale(vector);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[0][0] = _m[0][0] * vector._x;
    _m[0][1] = _m[0][1] * vector._y;
    _m[0][2] = _m[0][2] * vector._z;
    
    _m[1][0] = _m[1][0] * vector._x;
    _m[1][1] = _m[1][1] * vector._y;
    _m[1][2] = _m[1][2] * vector._z;
    
    _m[2][0] = _m[2][0] * vector._x;
    _m[2][1] = _m[2][1] * vector._y;
    _m[2][2] = _m[2][2] * vector._z;
    
    _m[3][0] = _m[3][0] * vector._x;
    _m[3][1] = _m[3][1] * vector._y;
    _m[3][2] = _m[3][2] * vector._z;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スケール乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::mulScale(f32 x, f32 y, f32 z)
{
#if GX_MATRIX_SAFE_MODE
    GxMatrix44 matrix;
    matrix.setScale(x, y, z);
    mulMatrix(matrix);
#else //GX_MATRIX_SAFE_MODE
    _m[0][0] = _m[0][0] * x;
    _m[0][1] = _m[0][1] * y;
    _m[0][2] = _m[0][2] * z;
    
    _m[1][0] = _m[1][0] * x;
    _m[1][1] = _m[1][1] * y;
    _m[1][2] = _m[1][2] * z;
    
    _m[2][0] = _m[2][0] * x;
    _m[2][1] = _m[2][1] * y;
    _m[2][2] = _m[2][2] * z;
    
    _m[3][0] = _m[3][0] * x;
    _m[3][1] = _m[3][1] * y;
    _m[3][2] = _m[3][2] * z;
#endif // !GX_MATRIX_SAFE_MODE
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 逆行列にする
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::inverse(void)
{
    const auto m00 =  GxMatrix33(_m[1][1], _m[1][2], _m[1][3], _m[2][1], _m[2][2], _m[2][3], _m[3][1], _m[3][2], _m[3][3]).getDeterminant();
    const auto m01 = -GxMatrix33(_m[0][1], _m[0][2], _m[0][3], _m[2][1], _m[2][2], _m[2][3], _m[3][1], _m[3][2], _m[3][3]).getDeterminant();
    const auto m02 =  GxMatrix33(_m[0][1], _m[0][2], _m[0][3], _m[1][1], _m[1][2], _m[1][3], _m[3][1], _m[3][2], _m[3][3]).getDeterminant();
    const auto m03 = -GxMatrix33(_m[0][1], _m[0][2], _m[0][3], _m[1][1], _m[1][2], _m[1][3], _m[2][1], _m[2][2], _m[2][3]).getDeterminant();
                                                                                                                                                                        
    const auto m10 = -GxMatrix33(_m[1][0], _m[1][2], _m[1][3], _m[2][0], _m[2][2], _m[2][3], _m[3][0], _m[3][2], _m[3][3]).getDeterminant();
    const auto m11 =  GxMatrix33(_m[0][0], _m[0][2], _m[0][3], _m[2][0], _m[2][2], _m[2][3], _m[3][0], _m[3][2], _m[3][3]).getDeterminant();
    const auto m12 = -GxMatrix33(_m[0][0], _m[0][2], _m[0][3], _m[1][0], _m[1][2], _m[1][3], _m[3][0], _m[3][2], _m[3][3]).getDeterminant();
    const auto m13 =  GxMatrix33(_m[0][0], _m[0][2], _m[0][3], _m[1][0], _m[1][2], _m[1][3], _m[2][0], _m[2][2], _m[2][3]).getDeterminant();
                                                                                                                                                                        
    const auto m20 =  GxMatrix33(_m[1][0], _m[1][1], _m[1][3], _m[2][0], _m[2][1], _m[2][3], _m[3][0], _m[3][1], _m[3][3]).getDeterminant();
    const auto m21 = -GxMatrix33(_m[0][0], _m[0][1], _m[0][3], _m[2][0], _m[2][1], _m[2][3], _m[3][0], _m[3][1], _m[3][3]).getDeterminant();
    const auto m22 =  GxMatrix33(_m[0][0], _m[0][1], _m[0][3], _m[1][0], _m[1][1], _m[1][3], _m[3][0], _m[3][1], _m[3][3]).getDeterminant();
    const auto m23 = -GxMatrix33(_m[0][0], _m[0][1], _m[0][3], _m[1][0], _m[1][1], _m[1][3], _m[2][0], _m[2][1], _m[2][3]).getDeterminant();
                                                                                                                                                                        
    const auto m30 = -GxMatrix33(_m[1][0], _m[1][1], _m[1][2], _m[2][0], _m[2][1], _m[2][2], _m[3][0], _m[3][1], _m[3][2]).getDeterminant();
    const auto m31 =  GxMatrix33(_m[0][0], _m[0][1], _m[0][2], _m[2][0], _m[2][1], _m[2][2], _m[3][0], _m[3][1], _m[3][2]).getDeterminant();
    const auto m32 = -GxMatrix33(_m[0][0], _m[0][1], _m[0][2], _m[1][0], _m[1][1], _m[1][2], _m[3][0], _m[3][1], _m[3][2]).getDeterminant();
    const auto m33 =  GxMatrix33(_m[0][0], _m[0][1], _m[0][2], _m[1][0], _m[1][1], _m[1][2], _m[2][0], _m[2][1], _m[2][2]).getDeterminant();
                                                                                                                                                                        
    const auto d = 1.0f / getDeterminant();
 
    _m[0][0] = m00 * d;
    _m[0][1] = m01 * d;
    _m[0][2] = m02 * d;
    _m[0][3] = m03 * d;
 
    _m[1][0] = m10 * d;
    _m[1][1] = m11 * d;
    _m[1][2] = m12 * d;
    _m[1][3] = m13 * d;
 
    _m[2][0] = m20 * d;
    _m[2][1] = m21 * d;
    _m[2][2] = m22 * d;
    _m[2][3] = m23 * d;
 
    _m[3][0] = m30 * d;
    _m[3][1] = m31 * d;
    _m[3][2] = m32 * d;
    _m[3][3] = m33 * d;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 転置する
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxMatrix44& GxMatrix44::transpose(void)
{
    const auto m00 = _m[0][0];
    const auto m01 = _m[1][0];
    const auto m02 = _m[2][0];
    const auto m03 = _m[3][0];
                    
    const auto m10 = _m[0][1];
    const auto m11 = _m[1][1];
    const auto m12 = _m[2][1];
    const auto m13 = _m[3][1];
                    
    const auto m20 = _m[0][2];
    const auto m21 = _m[1][2];
    const auto m22 = _m[2][2];
    const auto m23 = _m[3][2];
                    
    const auto m30 = _m[0][3];
    const auto m31 = _m[1][3];
    const auto m32 = _m[2][3];
    const auto m33 = _m[3][3];
 
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
    _m[0][3] = m03;
               
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
    _m[1][3] = m13;
               
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
    _m[2][3] = m23;
 
    _m[3][0] = m30;
    _m[3][1] = m31;
    _m[3][2] = m32;
    _m[3][3] = m33;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 0を設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxMatrix44::setZero(void)
{
#if defined(GX_USE_SSE2)
    _r[0] = _mm_setzero_ps();
    _r[1] = _mm_setzero_ps();
    _r[2] = _mm_setzero_ps();
    _r[3] = _mm_setzero_ps();
#else //GX_USE_SSE2
    for( u32 c = 0; c < 4; c++ )
    {
        _m[c][0] = 0.0f;
        _m[c][1] = 0.0f;
        _m[c][2] = 0.0f;
        _m[c][3] = 0.0f;
    }
#endif // !GX_USE_SSE2
}
 
//===========================================================================
// GxMatrixAffineGpu
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffineGpu::GxMatrixAffineGpu(const GxMatrixAffine& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[1][0];
    _m[0][2] = matrix._m[2][0];
    _m[0][3] = matrix._m[3][0];
 
    _m[1][0] = matrix._m[0][1];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[2][1];
    _m[1][3] = matrix._m[3][1];
 
    _m[2][0] = matrix._m[0][2];
    _m[2][1] = matrix._m[1][2];
    _m[2][2] = matrix._m[2][2];
    _m[2][3] = matrix._m[3][2];
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffineGpu::GxMatrixAffineGpu( f32 m00, f32 m01, f32 m02, f32 m03,
                                                f32 m10, f32 m11, f32 m12, f32 m13,
                                                f32 m20, f32 m21, f32 m22, f32 m23)
{
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
    _m[0][3] = m03;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
    _m[1][3] = m13;
 
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
    _m[2][3] = m23;
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrixAffineGpu::GxMatrixAffineGpu(const GxMatrixAffineGpu& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
    _m[0][3] = matrix._m[0][3];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
    _m[1][3] = matrix._m[1][3];
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
    _m[2][3] = matrix._m[2][3];
}
 
//===========================================================================
// GxMatrix44Gpu
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44Gpu::GxMatrix44Gpu(const GxMatrix44& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[1][0];
    _m[0][2] = matrix._m[2][0];
    _m[0][3] = matrix._m[3][0];
 
    _m[1][0] = matrix._m[0][1];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[2][1];
    _m[1][3] = matrix._m[3][1];
 
    _m[2][0] = matrix._m[0][2];
    _m[2][1] = matrix._m[1][2];
    _m[2][2] = matrix._m[2][2];
    _m[2][3] = matrix._m[3][2];
 
    _m[3][0] = matrix._m[0][3];
    _m[3][1] = matrix._m[1][3];
    _m[3][2] = matrix._m[2][3];
    _m[3][3] = matrix._m[3][3];
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44Gpu::GxMatrix44Gpu( f32 m00, f32 m01, f32 m02, f32 m03,
                                        f32 m10, f32 m11, f32 m12, f32 m13,
                                        f32 m20, f32 m21, f32 m22, f32 m23,
                                        f32 m30, f32 m31, f32 m32, f32 m33)
{
    _m[0][0] = m00;
    _m[0][1] = m01;
    _m[0][2] = m02;
    _m[0][3] = m03;
 
    _m[1][0] = m10;
    _m[1][1] = m11;
    _m[1][2] = m12;
    _m[1][3] = m13;
 
    _m[2][0] = m20;
    _m[2][1] = m21;
    _m[2][2] = m22;
    _m[2][3] = m23;
    
    _m[3][0] = m30;
    _m[3][1] = m31;
    _m[3][2] = m32;
    _m[3][3] = m33;
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_INLINE GxMatrix44Gpu::GxMatrix44Gpu(const GxMatrix44Gpu& matrix)
{
    _m[0][0] = matrix._m[0][0];
    _m[0][1] = matrix._m[0][1];
    _m[0][2] = matrix._m[0][2];
    _m[0][3] = matrix._m[0][3];
 
    _m[1][0] = matrix._m[1][0];
    _m[1][1] = matrix._m[1][1];
    _m[1][2] = matrix._m[1][2];
    _m[1][3] = matrix._m[1][3];
 
    _m[2][0] = matrix._m[2][0];
    _m[2][1] = matrix._m[2][1];
    _m[2][2] = matrix._m[2][2];
    _m[2][3] = matrix._m[2][3];
 
    _m[3][0] = matrix._m[3][0];
    _m[3][1] = matrix._m[3][1];
    _m[3][2] = matrix._m[3][2];
    _m[3][3] = matrix._m[3][3];
}
 
GX_CORE_NAMESPACE_END()