///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Compute the determinant of the Matrix
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
float Matrix4x4::Determinant() const
{
return m[0][0] * CoFactor(0, 0) +
m[0][1] * CoFactor(0, 1) +
m[0][2] * CoFactor(0, 2) +
m[0][3] * CoFactor(0, 3);
}
void m_inverse(MAT *feed, MAT *result)
{
MAT * tmp;
tmp = m_get(feed->rows, feed->cols);
CoFactor(feed->me, feed->cols, tmp->me);
Transpose(tmp->me, tmp->cols);
m_scalar_divide(tmp, result, m_det(feed));
m_free(tmp);
}
float NjFloat4x4::Determinant() const
{
return m[0] * CoFactor( 0, 0 ) + m[1] * CoFactor( 0, 1 ) + m[2] * CoFactor( 0, 2 ) + m[3] * CoFactor( 0, 3 );
}
NjFloat4x4 NjFloat4x4::Inverse() const
{
float Det = Determinant();
ASSERT( abs(Det) > 1e-6f, "Matrix is not inversible !" );
Det = 1.0f / Det;
NjFloat4x4 Temp;
Temp.m[4*0+0] = CoFactor( 0, 0 ) * Det;
Temp.m[4*1+0] = CoFactor( 0, 1 ) * Det;
Temp.m[4*2+0] = CoFactor( 0, 2 ) * Det;
Temp.m[4*3+0] = CoFactor( 0, 3 ) * Det;
Temp.m[4*0+1] = CoFactor( 1, 0 ) * Det;
Temp.m[4*1+1] = CoFactor( 1, 1 ) * Det;
Temp.m[4*2+1] = CoFactor( 1, 2 ) * Det;
Temp.m[4*3+1] = CoFactor( 1, 3 ) * Det;
Temp.m[4*0+2] = CoFactor( 2, 0 ) * Det;
Temp.m[4*1+2] = CoFactor( 2, 1 ) * Det;
Temp.m[4*2+2] = CoFactor( 2, 2 ) * Det;
Temp.m[4*3+2] = CoFactor( 2, 3 ) * Det;
Temp.m[4*0+3] = CoFactor( 3, 0 ) * Det;
Temp.m[4*1+3] = CoFactor( 3, 1 ) * Det;
Temp.m[4*2+3] = CoFactor( 3, 2 ) * Det;
Temp.m[4*3+3] = CoFactor( 3, 3 ) * Det;
return Temp;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Compute the inverse of the matrix
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Matrix4x4& Matrix4x4::Invert()
{
float Det = Determinant();
Matrix4x4 Temp;
if(fabsf(Det) < MATRIX4X4_EPSILON)
return *this; // The matrix is not invertible! Singular case!
float IDet = 1.0f / Det;
Temp.m[0][0] = CoFactor(0,0) * IDet;
Temp.m[1][0] = CoFactor(0,1) * IDet;
Temp.m[2][0] = CoFactor(0,2) * IDet;
Temp.m[3][0] = CoFactor(0,3) * IDet;
Temp.m[0][1] = CoFactor(1,0) * IDet;
Temp.m[1][1] = CoFactor(1,1) * IDet;
Temp.m[2][1] = CoFactor(1,2) * IDet;
Temp.m[3][1] = CoFactor(1,3) * IDet;
Temp.m[0][2] = CoFactor(2,0) * IDet;
Temp.m[1][2] = CoFactor(2,1) * IDet;
Temp.m[2][2] = CoFactor(2,2) * IDet;
Temp.m[3][2] = CoFactor(2,3) * IDet;
Temp.m[0][3] = CoFactor(3,0) * IDet;
Temp.m[1][3] = CoFactor(3,1) * IDet;
Temp.m[2][3] = CoFactor(3,2) * IDet;
Temp.m[3][3] = CoFactor(3,3) * IDet;
*this = Temp;
return *this;
}
