TITANIC: Rename DMatrix to DAffine, thanks to wjp

14 files changed, 77 insertions, 75 deletions

diff --git a/engines/titanic/star_control/base_stars.cpp b/engines/titanic/star_control/base_stars.cpp
index dddc399dc7..94208e7374 100644
--- a/engines/titanic/star_control/base_stars.cpp
+++ b/engines/titanic/star_control/base_stars.cpp
@@ -560,7 +560,7 @@ int CBaseStars::baseFn2(CSurfaceArea *surfaceArea, CStarCamera *camera) {
 /*------------------------------------------------------------------------*/
 
 void CStarVector::apply() {
-	_owner->addMatrixRow(_vector);
+	_owner->adDAffineRow(_vector);
 }
 
 } // End of namespace Titanic
diff --git a/engines/titanic/star_control/dmatrix.cpp b/engines/titanic/star_control/daffine.cpp
index 4f9b22d6a5..a7bed770c7 100644
--- a/engines/titanic/star_control/dmatrix.cpp
+++ b/engines/titanic/star_control/daffine.cpp
@@ -20,19 +20,19 @@
  *
  */
 
-#include "titanic/star_control/dmatrix.h"
+#include "titanic/star_control/daffine.h"
 #include "titanic/star_control/fmatrix.h"
 #include "titanic/star_control/matrix_transform.h"
 
 namespace Titanic {
 
-DMatrix *DMatrix::_static;
+DAffine *DAffine::_static;
 
-DMatrix::DMatrix() :
+DAffine::DAffine() :
 	_col1(0.0, 0.0, 0.0), _col2(0.0, 0.0, 0.0), _col3(0.0, 0.0, 0.0) {
 }
 
-DMatrix::DMatrix(int mode, const DVector &src) {
+DAffine::DAffine(int mode, const DVector &src) {
 	switch (mode) {
 	case 0:
 		_col1._x = 1.0;
@@ -55,26 +55,26 @@ DMatrix::DMatrix(int mode, const DVector &src) {
 	}
 }
 
-DMatrix::DMatrix(Axis axis, double amount) {
+DAffine::DAffine(Axis axis, double amount) {
 	setRotationMatrix(axis, amount);
 }
 
-DMatrix::DMatrix(const FMatrix &src) {
+DAffine::DAffine(const FMatrix &src) {
 	_col1 = src._row1;
 	_col2 = src._row2;
 	_col3 = src._row3;
 }
 
-void DMatrix::init() {
+void DAffine::init() {
 	_static = nullptr;
 }
 
-void DMatrix::deinit() {
+void DAffine::deinit() {
 	delete _static;
 	_static = nullptr;
 }
 
-void DMatrix::setRotationMatrix(Axis axis, double amount) {
+void DAffine::setRotationMatrix(Axis axis, double amount) {
 	const double FACTOR = 0.0174532925199433;
 	double sinVal = sin(amount * FACTOR);
 	double cosVal = cos(amount * FACTOR);
@@ -109,7 +109,7 @@ void DMatrix::setRotationMatrix(Axis axis, double amount) {
 	}
 }
 
-DMatrix DMatrix::fn1() const {
+DAffine DAffine::inverseTransform() const {
 	double val1 = _col1._x * _col3._z * _col2._y;
 	double val2 = 0.0;
 	double val3 = val1;
@@ -153,7 +153,7 @@ DMatrix DMatrix::fn1() const {
 	double val8 = _col3._z * _col2._y;
 	double val9 = 1.0 / val7;
 
-	DMatrix m;
+	DAffine m;
 	m._col1._x = (val8 - val3) * val9;
 	m._col2._x = -((_col3._z * _col2._x - _col3._x * _col2._z) * val9);
 	m._col3._x = (_col3._y * _col2._x - _col3._x * _col2._y) * val9;
@@ -174,7 +174,7 @@ DMatrix DMatrix::fn1() const {
 	return m;
 }
 
-void DMatrix::loadTransform(const CMatrixTransform &src) {
+void DAffine::loadTransform(const CMatrixTransform &src) {
 	double total = src.fn1();
 	double factor = (total <= 0.0) ? 0.0 : 2.0 / total;
 	DVector temp1V = src._vector * factor;
@@ -201,8 +201,8 @@ void DMatrix::loadTransform(const CMatrixTransform &src) {
 	_col4._z = 0;
 }
 
-DMatrix DMatrix::fn4(const DMatrix &m) {
-	DMatrix dm;
+DAffine DAffine::compose(const DAffine &m) {
+	DAffine dm;
 	dm._col1._x = m._col3._x * _col1._z + m._col2._x * _col1._y
 		+ m._col1._x * _col1._x;
 	dm._col1._y = _col1._x * m._col1._y + m._col3._y * _col1._z
diff --git a/engines/titanic/star_control/dmatrix.h b/engines/titanic/star_control/daffine.h
index 45837ce19a..50f8b9580b 100644
--- a/engines/titanic/star_control/dmatrix.h
+++ b/engines/titanic/star_control/daffine.h
@@ -20,8 +20,8 @@
  *
  */
 
-#ifndef TITANIC_DMATRIX_H
-#define TITANIC_DMATRIX_H
+#ifndef TITANIC_DAFFINE_H
+#define TITANIC_DAFFINE_H
 
 #include "titanic/star_control/dvector.h"
 #include "titanic/star_control/fvector.h"
@@ -32,12 +32,14 @@ class FMatrix;
 class CMatrixTransform;
 
 /**
- * Double based matrix class.
- * @remarks		TODO: See if it can be merged with FMatrix
+ * Affine transformation.
+ *
+ * Handles transformation functions between affine spaces,
+ * which preserves points, straight lines and planes
  */
-class DMatrix {
+class DAffine {
 private:
-	static DMatrix *_static;
+	static DAffine *_static;
 public:
 	DVector _col1;
 	DVector _col2;
@@ -47,23 +49,23 @@ public:
 	static void init();
 	static void deinit();
 public:
-	DMatrix();
-	DMatrix(int mode, const DVector &src);
-	DMatrix(Axis axis, double amount);
-	DMatrix(const FMatrix &src);
+	DAffine();
+	DAffine(int mode, const DVector &src);
+	DAffine(Axis axis, double amount);
+	DAffine(const FMatrix &src);
 
 	/**
 	 * Sets up a matrix for rotating on a given axis by a given amount
 	 */
 	void setRotationMatrix(Axis axis, double amount);
 
-	DMatrix fn1() const;
+	DAffine inverseTransform() const;
 
 	void loadTransform(const CMatrixTransform &src);
 
-	DMatrix fn4(const DMatrix &m);
+	DAffine compose(const DAffine &m);
 };
 
 } // End of namespace Titanic
 
-#endif /* TITANIC_DMATRIX_H */
+#endif /* TITANIC_DAFFINE_H */
diff --git a/engines/titanic/star_control/dvector.cpp b/engines/titanic/star_control/dvector.cpp
index 3f09b12500..a8754e7d64 100644
--- a/engines/titanic/star_control/dvector.cpp
+++ b/engines/titanic/star_control/dvector.cpp
@@ -21,7 +21,7 @@
  */
 
 #include "titanic/star_control/dvector.h"
-#include "titanic/star_control/dmatrix.h"
+#include "titanic/star_control/DAffine.h"
 #include "common/algorithm.h"
 
 namespace Titanic {
@@ -40,7 +40,7 @@ double DVector::getDistance(const DVector &src) {
 	return sqrt((src._x - _x) * (src._x - _x) + (src._y - _y) * (src._y - _y) + (src._z - _z) * (src._z - _z));
 }
 
-DVector DVector::fn1(const DMatrix &m) {
+DVector DVector::fn1(const DAffine &m) {
 	DVector dest;
 	dest._x = m._col3._x * _z + m._col2._x * _y + m._col1._x * _x + m._col4._x;
 	dest._y = m._col2._y * _y + m._col3._y * _z + m._col1._y * _x + m._col4._y;
@@ -80,31 +80,31 @@ DVector DVector::fn3() const {
 	return dest;
 }
 
-DMatrix DVector::fn4(const DVector &v) {
+DAffine DVector::fn4(const DVector &v) {
 	const double FACTOR = 180.0 / M_PI;
-	DMatrix matrix1, matrix2, matrix3, matrix4;
+	DAffine matrix1, matrix2, matrix3, matrix4;
 
 	DVector vector1 = fn3();
 	matrix1.setRotationMatrix(X_AXIS, vector1._y * FACTOR);
 	matrix2.setRotationMatrix(Y_AXIS, -(vector1._z * FACTOR));
-	matrix3 = matrix1.fn4(matrix2);
-	matrix4 = matrix3.fn1();
+	matrix3 = matrix1.compose(matrix2);
+	matrix4 = matrix3.inverseTransform();
 
 	vector1 = v.fn3();
 	matrix1.setRotationMatrix(X_AXIS, vector1._y * FACTOR);
 	matrix2.setRotationMatrix(Y_AXIS, -(vector1._z * FACTOR));
-	matrix3 = matrix1.fn4(matrix2);
+	matrix3 = matrix1.compose(matrix2);
 
-	return matrix4.fn4(matrix3);
+	return matrix4.compose(matrix3);
 }
 
-DMatrix DVector::fn5() const {
+DAffine DVector::fn5() const {
 	const double FACTOR = 180.0 / M_PI;
 	DVector v1 = fn3();
-	DMatrix m1, m2;
+	DAffine m1, m2;
 	m1.setRotationMatrix(X_AXIS, v1._y * FACTOR);
 	m2.setRotationMatrix(Y_AXIS, -(v1._z * FACTOR));
-	return m1.fn4(m2);
+	return m1.compose(m2);
 }
 
 } // End of namespace Titanic
diff --git a/engines/titanic/star_control/dvector.h b/engines/titanic/star_control/dvector.h
index ef54745f3e..94df30ebbd 100644
--- a/engines/titanic/star_control/dvector.h
+++ b/engines/titanic/star_control/dvector.h
@@ -27,7 +27,7 @@
 
 namespace Titanic {
 
-class DMatrix;
+class DAffine;
 
 /**
  * Double based vector class.
@@ -48,11 +48,11 @@ public:
 	 */
 	double getDistance(const DVector &src);
 
-	DVector fn1(const DMatrix &m);
+	DVector fn1(const DAffine &m);
 	void fn2(double angle);
 	DVector fn3() const;
-	DMatrix fn4(const DVector &v);
-	DMatrix fn5() const;
+	DAffine fn4(const DVector &v);
+	DAffine fn5() const;
 
 	/**
 	 * Returns true if the passed vector equals this one
diff --git a/engines/titanic/star_control/fmatrix.cpp b/engines/titanic/star_control/fmatrix.cpp
index bf5754af91..e58797d4ae 100644
--- a/engines/titanic/star_control/fmatrix.cpp
+++ b/engines/titanic/star_control/fmatrix.cpp
@@ -21,7 +21,7 @@
  */
 
 #include "titanic/star_control/fmatrix.h"
-#include "titanic/star_control/dmatrix.h"
+#include "titanic/star_control/DAffine.h"
 
 namespace Titanic {
 
@@ -29,7 +29,7 @@ FMatrix::FMatrix() :
 	_row1(1.0, 0.0, 0.0), _row2(0.0, 1.0, 0.0), _row3(0.0, 0.0, 1.0) {
 }
 
-FMatrix::FMatrix(const DMatrix &src) {
+FMatrix::FMatrix(const DAffine &src) {
 	copyFrom(src);
 }
 
@@ -39,7 +39,7 @@ FMatrix::FMatrix(const FMatrix &src) {
 	_row3 = src._row3;
 }
 
-void FMatrix::copyFrom(const DMatrix &src) {
+void FMatrix::copyFrom(const DAffine &src) {
 	_row1 = src._col1;
 	_row2 = src._col2;
 	_row3 = src._col3;
diff --git a/engines/titanic/star_control/fmatrix.h b/engines/titanic/star_control/fmatrix.h
index 34f39cf568..95bb91cf73 100644
--- a/engines/titanic/star_control/fmatrix.h
+++ b/engines/titanic/star_control/fmatrix.h
@@ -28,26 +28,26 @@
 
 namespace Titanic {
 
-class DMatrix;
+class DAffine;
 class DVector;
 
 /**
  * Floating point matrix class.
- * @remarks		TODO: See if it can be merged with DMatrix
+ * @remarks		TODO: See if it can be merged with DAffine
  */
 class FMatrix {
 private:
 	/**
 	 * Copys data from a given source
 	 */
-	void copyFrom(const DMatrix &src);
+	void copyFrom(const DAffine &src);
 public:
 	FVector _row1;
 	FVector _row2;
 	FVector _row3;
 public:
 	FMatrix();
-	FMatrix(const DMatrix &src);
+	FMatrix(const DAffine &src);
 	FMatrix(const FMatrix &src);
 
 	/**
diff --git a/engines/titanic/star_control/matrix_transform.cpp b/engines/titanic/star_control/matrix_transform.cpp
index 20cadd580f..226dffa2ca 100644
--- a/engines/titanic/star_control/matrix_transform.cpp
+++ b/engines/titanic/star_control/matrix_transform.cpp
@@ -54,7 +54,7 @@ CMatrixTransform CMatrixTransform::resize(double factor) const {
 	return dest;
 }
 
-void CMatrixTransform::fn4(const DMatrix &m) {
+void CMatrixTransform::fn4(const DAffine &m) {
 	double total = m._col1._x + m._col3._z + m._col2._y + 1.0;
 
 	if (total <= 0.00001) {
diff --git a/engines/titanic/star_control/matrix_transform.h b/engines/titanic/star_control/matrix_transform.h
index fb7bfd3cc6..9c5ba3856e 100644
--- a/engines/titanic/star_control/matrix_transform.h
+++ b/engines/titanic/star_control/matrix_transform.h
@@ -23,7 +23,7 @@
 #ifndef TITANIC_MATRIX_TRANSFORM_H
 #define TITANIC_MATRIX_TRANSFORM_H
 
-#include "titanic/star_control/dmatrix.h"
+#include "titanic/star_control/DAffine.h"
 
 namespace Titanic {
 
@@ -48,7 +48,7 @@ public:
 	void copyFrom(const CMatrixTransform &src);
 
 	double fn1() const;
-	void fn4(const DMatrix &m);
+	void fn4(const DAffine &m);
 	CMatrixTransform fn5(double percent, const CMatrixTransform &src);
 };
 
diff --git a/engines/titanic/star_control/orientation_changer.cpp b/engines/titanic/star_control/orientation_changer.cpp
index 1aff475cf0..14f0100eb6 100644
--- a/engines/titanic/star_control/orientation_changer.cpp
+++ b/engines/titanic/star_control/orientation_changer.cpp
@@ -21,7 +21,7 @@
  */
 
 #include "titanic/star_control/orientation_changer.h"
-#include "titanic/star_control/dmatrix.h"
+#include "titanic/star_control/DAffine.h"
 
 namespace Titanic {
 
@@ -41,7 +41,7 @@ FMatrix COrientationChanger::getOrientation(double percent) {
 	} else {
 		CMatrixTransform tfm = _sub1.fn5(percent, _sub2);
 
-		DMatrix m1;
+		DAffine m1;
 		m1.loadTransform(tfm);
 		return m1;
 	}
diff --git a/engines/titanic/star_control/star_camera.cpp b/engines/titanic/star_control/star_camera.cpp
index d3487e2f65..dc8e6845c2 100644
--- a/engines/titanic/star_control/star_camera.cpp
+++ b/engines/titanic/star_control/star_camera.cpp
@@ -23,7 +23,7 @@
 #include "titanic/star_control/star_camera.h"
 #include "titanic/star_control/unmarked_camera_mover.h"
 #include "titanic/star_control/marked_camera_mover.h"
-#include "titanic/star_control/dmatrix.h"
+#include "titanic/star_control/DAffine.h"
 #include "titanic/star_control/fmatrix.h"
 #include "titanic/titanic.h"
 
@@ -278,21 +278,21 @@ void CStarCamera::setViewportAngle(const FPoint &angles) {
 	} else if (_matrixRow == 1) {
 		// 2 markers locked in
 		FVector tempV2;
-		DMatrix m1, m2, sub;
+		DAffine m1, m2, sub;
 		DVector mrow1, mrow2, mrow3;
 		DVector tempV1, diffV, multV, multV2, tempV3, tempV4, tempV5, tempV6, tempV7;
 		DVector tempV8, tempV9, tempV10, tempV11, tempV12;
 		DVector tempV13, tempV14, tempV15, tempV16;
 
-		DMatrix subX(0, _matrix._row1);
-		DMatrix subY(Y_AXIS, angles._y);
+		DAffine subX(0, _matrix._row1);
+		DAffine subY(Y_AXIS, angles._y);
 
 		tempV1 = _matrix._row2 - _matrix._row1;
 		diffV = tempV1;
 		m1 = diffV.fn5();
-		m1 = m1.fn4(subX);
-		subX = m1.fn1();
-		subX = subX.fn4(subY);
+		m1 = m1.compose(subX);
+		subX = m1.inverseTransform();
+		subX = subX.compose(subY);
 
 		FMatrix m3 = _viewport.getOrientation();
 		tempV2 = _viewport._position;
@@ -345,7 +345,7 @@ void CStarCamera::setViewportAngle(const FPoint &angles) {
 	}
 }
 
-bool CStarCamera::addMatrixRow(const FVector v) {
+bool CStarCamera::adDAffineRow(const FVector v) {
 	if (_matrixRow >= 2)
 		return false;
 
@@ -457,14 +457,14 @@ void CStarCamera::lockMarker2(CViewport *viewport, const FVector &v) {
 	if (_matrixRow != 0)
 		return;
 
-	DMatrix m2(X_AXIS, _matrix._row1);
+	DAffine m2(X_AXIS, _matrix._row1);
 	DVector tempV1 = v - _matrix._row1;
-	DMatrix m1 = tempV1.fn5();
-	m1 = m1.fn4(m2);
-	m2 = m1.fn1();
+	DAffine m1 = tempV1.fn5();
+	m1 = m1.compose(m2);
+	m2 = m1.inverseTransform();
 	
 	DVector tempV2 = _viewport._position;
-	DMatrix m4;
+	DAffine m4;
 	m4._col1 = viewport->_position;
 	m4._col2 = DVector(0.0, 0.0, 0.0);
 	m4._col3 = DVector(0.0, 0.0, 0.0);
diff --git a/engines/titanic/star_control/star_camera.h b/engines/titanic/star_control/star_camera.h
index 454dfb86c4..1f0e12ccd9 100644
--- a/engines/titanic/star_control/star_camera.h
+++ b/engines/titanic/star_control/star_camera.h
@@ -162,7 +162,7 @@ public:
 	 * @remarks		This can't be a pass-by-reference, since adding
 	 * the vector for the star destroys the calling star vector
 	 */
-	virtual bool addMatrixRow(const FVector v);
+	virtual bool adDAffineRow(const FVector v);
 
 	virtual bool removeMatrixRow();
 	virtual void proc36(double *v1, double *v2, double *v3, double *v4);
diff --git a/engines/titanic/star_control/star_control.cpp b/engines/titanic/star_control/star_control.cpp
index 3a0eeae02b..f140e86fb8 100644
--- a/engines/titanic/star_control/star_control.cpp
+++ b/engines/titanic/star_control/star_control.cpp
@@ -23,7 +23,7 @@
 #include "titanic/support/screen_manager.h"
 #include "titanic/pet_control/pet_control.h"
 #include "titanic/star_control/star_control.h"
-#include "titanic/star_control/dmatrix.h"
+#include "titanic/star_control/DAffine.h"
 #include "titanic/star_control/error_code.h"
 #include "titanic/star_control/fpose.h"
 #include "titanic/star_control/star_camera.h"
@@ -44,12 +44,12 @@ END_MESSAGE_MAP()
 CStarControl::CStarControl() : _enabled(false), _petControl(nullptr),
 		_starRect(20, 10, 620, 350) {
 	CStarCamera::init();
-	DMatrix::init();
+	DAffine::init();
 }
 
 CStarControl::~CStarControl() {
 	CStarCamera::deinit();
-	DMatrix::deinit();
+	DAffine::deinit();
 }
 
 void CStarControl::save(SimpleFile *file, int indent) {
diff --git a/engines/titanic/star_control/unmarked_camera_mover.cpp b/engines/titanic/star_control/unmarked_camera_mover.cpp
index bafab7b6a8..017e348fda 100644
--- a/engines/titanic/star_control/unmarked_camera_mover.cpp
+++ b/engines/titanic/star_control/unmarked_camera_mover.cpp
@@ -21,7 +21,7 @@
  */
 
 #include "titanic/star_control/unmarked_camera_mover.h"
-#include "titanic/star_control/dmatrix.h"
+#include "titanic/star_control/DAffine.h"
 #include "titanic/star_control/dvector.h"
 #include "titanic/titanic.h"
 #include "common/textconsole.h"
@@ -47,8 +47,8 @@ void CUnmarkedCameraMover::proc10(const FVector &v1, const FVector &v2, const FV
 
 	DVector vector1 = v1;
 	DVector vector2 = v2;
-	DMatrix matrix1 = vector2.fn4(vector1);
-	DMatrix matrix2 = matrix1.fn4(m);
+	DAffine matrix1 = vector2.fn4(vector1);
+	DAffine matrix2 = matrix1.compose(m);
 
 	_autoMover.proc3(m, matrix2);
 	incLockCount();