nerdcruft/libcruft-util
1
0
Fork 0
Code Issues Releases Activity

matrix: move identity and zeroes into constexpr funcs

Browse Source
This commit is contained in:
Danny Robson 2016-10-17 22:34:53 +11:00
parent e96ef7af32
commit e549f3d554
8 changed files with 32 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
matrix.cpp
View File

@ -392,11 +392,6 @@ matrix<S,T>::rotation (T angle, util::vector<3,T> about)
} };
}
//-----------------------------------------------------------------------------
template <size_t S, typename T>
const matrix<S,T>
matrix<S,T>::ZEROES { 0 };
//-----------------------------------------------------------------------------
template struct util::matrix<2,float>;

4
matrix.hpp
View File

@ -78,8 +78,8 @@ namespace util {
static matrix<4,T> rotation (T angle, util::vector<3,T> about);
// Constant matrices
static const matrix IDENTITY;
static const matrix ZEROES;
static constexpr matrix identity ();
static constexpr matrix zeroes ();
};

23
matrix.ipp
View File

@ -183,6 +183,29 @@ MATRIX_SCALAR_OP(-)
#undef MATRIX_SCALAR_OP
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
constexpr
util::matrix<S,T>
util::matrix<S,T>::zeroes (void)
{
return {0};
}
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
constexpr
util::matrix<S,T>
util::matrix<S,T>::identity (void)
{
auto m = zeroes ();
for (size_t i = 0; i < S; ++i)
m[i][i] = 1;
return m;
}
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
constexpr

13
matrix2.cpp
View File

@ -33,7 +33,7 @@ template float util::determinant (const matrix<2,float>&);
template double util::determinant (const matrix<2,double>&);
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
matrix<S,T>
util::inverse (const matrix<S,T> &m)
@ -46,19 +46,12 @@ util::inverse (const matrix<S,T> &m)
} / determinant (m);
}
//-----------------------------------------------------------------------------
template util::matrix<2,float> util::inverse (const matrix<2,float>&);
template util::matrix<2,double> util::inverse (const matrix<2,double>&);
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
const matrix<S,T>
matrix<S,T>::IDENTITY = { {
{ 1, 0, },
{ 0, 1 }
} };
///////////////////////////////////////////////////////////////////////////////
template struct util::matrix<2,float>;
template struct util::matrix<2,double>;

9
matrix3.cpp
View File

@ -61,15 +61,6 @@ template util::matrix<3,float> util::inverse (const matrix<3,float>&);
template util::matrix<3,double> util::inverse (const matrix<3,double>&);
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
const matrix<S,T>
matrix<S,T>::IDENTITY = { {
{ 1, 0, 0, },
{ 0, 1, 0, },
{ 0, 0, 1 }
} };
///////////////////////////////////////////////////////////////////////////////
template struct util::matrix<3,float>;
template struct util::matrix<3,double>;

9
matrix4.cpp
View File

@ -75,15 +75,6 @@ template util::matrix<4,float> util::inverse (const matrix<4,float>&);
template util::matrix<4,double> util::inverse (const matrix<4,double>&);
///////////////////////////////////////////////////////////////////////////////
template <size_t S, typename T>
const matrix<S,T>
matrix<S,T>::IDENTITY = { { { 1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 } } };
///////////////////////////////////////////////////////////////////////////////
template struct util::matrix<4,float>;
template struct util::matrix<4,double>;

4
test/matrix.cpp
View File

@ -48,7 +48,7 @@ main (void)
{
// Identity matrix-vector multiplication
auto v = util::vector4f { 1.f, 2.f, 3.f, 4.f };
auto r = util::matrix4f::IDENTITY * v;
auto r = util::matrix4f::identity () * v;
tap.expect_eq (r, v, "identity matrix-vector multiplication");
}
@ -101,7 +101,7 @@ main (void)
bool success = true;
// Ensure identity inverts to identity
auto m = util::matrix4f::IDENTITY.inverse ();
auto m = util::matrix4f::identity ().inverse ();
for (size_t r = 0; r < m.rows; ++r)
for (size_t c = 0; c < m.cols; ++c)
if (r == c)

4
test/quaternion.cpp
View File

@ -65,7 +65,7 @@ main (void)
tap.expect_eq (
quaternionf::identity ().as_matrix (),
util::matrix4f::IDENTITY,
util::matrix4f::identity (),
"identity quaternion to matrix"
);
@ -93,7 +93,7 @@ main (void)
}
auto q = quaternionf::identity ();
auto m = util::matrix4f::IDENTITY;
auto m = util::matrix4f::identity ();
for (auto r: ROTATIONS) {
q = q.angle_axis (r.mag, r.axis) * q;