Mercurial > ldforge / file diff

--- a/src/basics.cpp	Thu Jan 04 19:52:24 2018 +0200
+++ b/src/basics.cpp	Thu Jan 04 20:21:36 2018 +0200
@@ -129,117 +129,78 @@
 	return false;
 }
 
-// =============================================================================
-//
-Matrix::Matrix(double vals[])
+Matrix::Matrix() :
+	coefficients {1, 0, 0, 0, 1, 0, 0, 0, 1} {}
+
+Matrix::Matrix(std::initializer_list<double> values)
 {
-	for (int i = 0; i < 9; ++i)
-		m_vals[i] = vals[i];
-}
-
-// =============================================================================
-//
-Matrix::Matrix(double fillval)
-{
-	for (int i = 0; i < 9; ++i)
-		m_vals[i] = fillval;
+	if (values.size() == 9)
+		memcpy(&coefficients[0], values.begin(), sizeof coefficients);
 }
 
-// =============================================================================
-//
-Matrix::Matrix(const std::initializer_list<double>& vals)
-{
-	if (vals.size() == 9)
-		memcpy(&m_vals[0], vals.begin(), sizeof m_vals);
-}
-
-// =============================================================================
-//
-void Matrix::dump() const
-{
-	for (int i = 0; i < 3; ++i)
-	{
-		for (int j = 0; j < 3; ++j)
-			print("%1\t", m_vals[i * 3 + j]);
-
-		print("\n");
-	}
-}
-
-// =============================================================================
-//
 QString Matrix::toString() const
 {
 	QString val;
 
-	for (int i = 0; i < 9; ++i)
+	for (int i = 0; i < countof(coefficients); ++i)
 	{
 		if (i > 0)
 			val += ' ';
 
-		val += QString::number(m_vals[i]);
+		val += QString::number(coefficients[i]);
 	}
 
 	return val;
 }
 
-// =============================================================================
-//
 void Matrix::zero()
 {
-	memset(&m_vals[0], 0, sizeof m_vals);
+	for (int i = 0; i < countof(coefficients); ++i)
+		coefficients[i] = 0;
 }
 
-// =============================================================================
-//
-Matrix Matrix::mult(const Matrix& other) const
+Matrix Matrix::operator*(const Matrix& other) const
 {
-	Matrix val;
-	val.zero();
+	Matrix result;
+	result.zero();
 
 	for (int i = 0; i < 3; ++i)
 	for (int j = 0; j < 3; ++j)
 	for (int k = 0; k < 3; ++k)
-		val[(i * 3) + j] += m_vals[(i * 3) + k] * other[(k * 3) + j];
+		result(i, j) += (*this)(i, k) * other(k, j);
 
-	return val;
+	return result;
 }
 
-// =============================================================================
-//
-Matrix& Matrix::operator= (const Matrix& other)
+Matrix& Matrix::operator=(const Matrix& other)
 {
-	memcpy(&m_vals[0], &other.m_vals[0], sizeof m_vals);
+	for (int i = 0; i < countof(coefficients); ++i)
+		(*this)[i] = other[i];
 	return *this;
 }
 
-// =============================================================================
-//
-double Matrix::getDeterminant() const
+double Matrix::determinant() const
 {
-	return (value(0) * value(4) * value(8)) +
-		  (value(1) * value(5) * value(6)) +
-		  (value(2) * value(3) * value(7)) -
-		  (value(2) * value(4) * value(6)) -
-		  (value(1) * value(3) * value(8)) -
-		  (value(0) * value(5) * value(7));
+	return
+		(*this)(0, 0) * (*this)(1, 1) * (*this)(2, 2) +
+		(*this)(0, 1) * (*this)(1, 2) * (*this)(2, 0) +
+		(*this)(0, 2) * (*this)(1, 0) * (*this)(2, 1) -
+		(*this)(0, 2) * (*this)(1, 1) * (*this)(2, 0) -
+		(*this)(0, 1) * (*this)(1, 0) * (*this)(2, 2) -
+		(*this)(0, 0) * (*this)(1, 2) * (*this)(2, 1);
 }
 
-// =============================================================================
-//
 bool Matrix::operator== (const Matrix& other) const
 {
-	for (int i = 0; i < 9; ++i)
+	for (int i = 0; i < countof(coefficients); ++i)
 	{
-		if (value(i) != other[i])
+		if ((*this)[i] != other[i])
 			return false;
 	}
 
 	return true;
 }
 
-// =============================================================================
-//
 LDBoundingBox::LDBoundingBox()
 {
 	reset();