Upgraded SimpleMath, added basic camera controls to the testmodule

src/Globals.h

@@ -0,0 +1,7 @@
+#pragma once
+
+struct Renderer;
+extern Renderer* gRenderer;
+
+struct GLFWwindow;
+extern GLFWwindow* gWindow;

src/SimpleMath/README

@@ -0,0 +1,10 @@
+This is a highly inefficient math library. It was conceived by Martin
+Felis <martin.felis@iwr.uni-heidelberg.de> while he was waiting for code to
+compile which used a highly efficient math library.
+
+It is intended to be used as a fast compiling substitute for the
+blazingly fast Eigen3 http://eigen.tuxfamily.org/index.php?title=Main_Page
+library and tries to mimic its API to a certain extent.
+
+Feel free to use it wherever you like. However, no guarantees are given
+that this code does what it says it would.

src/SimpleMath/SimpleMath.h

@@ -22,6 +22,10 @@ typedef SimpleMath::Fixed::Matrix<float, 3, 3> Matrix33f;
 typedef SimpleMath::Fixed::Matrix<float, 4, 4> Matrix44f;
 
 typedef SimpleMath::Dynamic::Matrix<double> VectorNd;
+typedef SimpleMath::Dynamic::Matrix<double> MatrixNd;
+
+typedef SimpleMath::Dynamic::Matrix<float> VectorNf;
+typedef SimpleMath::Dynamic::Matrix<float> MatrixNNf;
 
 }
 

src/SimpleMath/SimpleMath.h.orig

@@ -0,0 +1,24 @@
+#ifndef _SIMPLEMATH_H
+#define _SIMPLEMATH_H
+
+#include "SimpleMathFixed.h"
+#include "SimpleMathDynamic.h"
+#include "SimpleMathMixed.h"
+#include "SimpleMathQR.h"
+#include "SimpleMathCommaInitializer.h"
+
+typedef SimpleMath::Fixed::Matrix<int, 3, 1> Vector3i;
+
+typedef SimpleMath::Fixed::Matrix<double, 3, 1> Vector3d;
+typedef SimpleMath::Fixed::Matrix<double, 3, 3> Matrix33d;
+
+typedef SimpleMath::Fixed::Matrix<double, 4, 1> Vector4d;
+
+typedef SimpleMath::Fixed::Matrix<float, 3, 1> Vector3f;
+typedef SimpleMath::Fixed::Matrix<float, 4, 1> Vector4f;
+typedef SimpleMath::Fixed::Matrix<float, 3, 3> Matrix33f;
+typedef SimpleMath::Fixed::Matrix<float, 4, 4> Matrix44f;
+
+typedef SimpleMath::Dynamic::Matrix<double> VectorNd;
+
+#endif /* _SIMPLEMATH_H */

src/SimpleMath/SimpleMathBlock.h.orig

@@ -0,0 +1,220 @@
+/**
+ * This is a highly inefficient math library. It was conceived by Martin
+ * Felis <martin.felis@iwr.uni-heidelberg.de> while he was compiling code
+ * that uses a highly efficient math library.
+ *
+ * It is intended to be used as a fast compiling substitute for the
+ * blazingly fast Eigen3 library and tries to mimic its API to a certain
+ * extend.
+ *
+ * Feel free to use it wherever you like. However, no guarantees are given
+ * that this code does what it says it would.
+ */
+
+#ifndef SIMPLEMATHBLOCK_H
+#define SIMPLEMATHBLOCK_H
+
+#include <cstdlib>
+#include <cmath>
+#include <iostream>
+#include <assert.h>
+
+#include "compileassert.h"
+
+// #include "SimpleMathQR.h"
+
+/** \brief Namespace for a highly inefficient math library
+ *
+ */
+namespace SimpleMath {
+
+/** \brief Namespace for fixed size elements
+ */
+// forward declaration
+template <typename val_type, unsigned int nrows, unsigned int ncols>
+class Matrix;
+
+template <typename matrix_type, typename val_type>
+class Block {
+	public:
+		typedef val_type value_type;
+
+		Block() :
+			mParentRows(0),
+			mParentCols(0),
+			mParentRowStart(0),
+			mParentColStart(0)
+		{ }
+		Block (const matrix_type &matrix, const unsigned int row_start, const unsigned int col_start, const unsigned int row_count, const unsigned int col_count) :
+			mParentRows (matrix.rows()),
+			mParentCols (matrix.cols()),
+			mParentRowStart (row_start),
+			mParentColStart (col_start),
+			mRowCount (row_count),
+			mColCount (col_count),
+			mTransposed (false) {
+				assert (mParentRows >= mParentRowStart + mRowCount);
+				assert (mParentCols >= mParentColStart + mColCount);
+
+				// without the following line we could not create blocks from const
+				// matrices
+				mParentMatrix = const_cast<matrix_type*>(&matrix);
+			}
+
+		// copy data from the other block into this
+		Block& operator=(const Block &other) {
+			if (this != &other) {
+				if (mRowCount != other.rows() || mColCount != other.cols()) {
+					std::cerr << "Error: cannot assign blocks of different size (left is " << mRowCount << "x" << mColCount << " right is " << other.rows() << "x" << other.cols() << ")!" << std::endl;
+					abort();
+				}
+				
+				value_type* temp_values = new value_type [mRowCount * mColCount];
+
+				for (unsigned int i = 0; i < mRowCount; i++) {
+					for (unsigned int j = 0; j < mColCount; j++) {
+						temp_values[i * mColCount + j] = static_cast<value_type>(other(i,j));
+					}
+				}
+
+				for (unsigned int i = 0; i < mRowCount; i++) {
+					for (unsigned int j = 0; j < mColCount; j++) {
+						(*this)(i,j) = temp_values[i * mColCount + j];
+					}
+				}
+
+				delete[] temp_values;
+			}
+
+			return *this;
+		}
+
+		template <typename other_matrix_type>
+		// copy data from the other block into this
+		Block& operator=(const other_matrix_type &other) {
+			if (mRowCount != other.rows() || mColCount != other.cols()) {
+				std::cerr << "Error: cannot assign blocks of different size (left is " << mRowCount << "x" << mColCount << " right is " << other.rows() << "x" << other.cols() << ")!" << std::endl;
+				abort();
+			}
+
+			value_type *temp_values = new value_type[mRowCount * mColCount];
+
+			for (unsigned int i = 0; i < mRowCount; i++) {
+				for (unsigned int j = 0; j < mColCount; j++) {
+					temp_values[i * mColCount + j] = static_cast<value_type>(other(i,j));
+				}
+			}
+
+			for (unsigned int i = 0; i < mRowCount; i++) {
+				for (unsigned int j = 0; j < mColCount; j++) {
+					(*this)(i,j) = temp_values[i * mColCount + j];
+				}
+			}
+			
+			delete[] temp_values;
+
+			return *this;
+		}
+
+		template <typename other_matrix_type>
+    other_matrix_type operator+(const other_matrix_type& other) {
+      other_matrix_type result (this);
+
+      for (unsigned int i = 0; i < mRowCount; i++) {
+        for (unsigned int j = 0; j < mColCount; j++) {
+          result += other(i,j);
+        }
+      }
+
+      return result;
+    }
+    
+    template <typename other_matrix_type>
+    other_matrix_type operator-(const other_matrix_type& other) {
+      other_matrix_type result (this);
+
+      for (unsigned int i = 0; i < mRowCount; i++) {
+        for (unsigned int j = 0; j < mColCount; j++) {
+          result -= other(i,j);
+        }
+      }
+
+      return result;
+    }
+
+		unsigned int rows() const {
+			if (!mTransposed)
+				return mRowCount;
+
+			return mColCount;
+		}
+		unsigned int cols() const {
+			if (!mTransposed)
+				return mColCount;
+			
+			return mRowCount;
+		}
+		const val_type& operator() (const unsigned int i, const unsigned int j) const {
+
+			if (!mTransposed) {
+				assert (i < mRowCount);
+				assert (j < mColCount);
+				return (*mParentMatrix) (i + mParentRowStart, j + mParentColStart);
+			}
+
+			return (*mParentMatrix) (j + mParentRowStart, i + mParentColStart);
+		}
+
+		val_type& operator() (const unsigned int i, const unsigned int j) {
+			if (!mTransposed) {
+				assert (i < mRowCount);
+				assert (j < mColCount);
+				return (*mParentMatrix) (i + mParentRowStart, j + mParentColStart);
+			}
+
+			assert (j < mRowCount);
+			assert (i < mColCount);
+			return (*mParentMatrix) (j + mParentRowStart, i + mParentColStart);
+		}
+
+		Block transpose() const {
+			Block result (*this);
+			result.mTransposed = mTransposed ^ true;
+			return result;
+		}
+
+	private:
+		matrix_type *mParentMatrix;
+		const unsigned int mParentRows;
+		const unsigned int mParentCols;
+		const unsigned int mParentRowStart;
+		const unsigned int mParentColStart;
+		const unsigned int mRowCount;
+		const unsigned int mColCount;
+		bool mTransposed;
+};
+
+template <typename matrix_type, typename val_type>
+inline std::ostream& operator<<(std::ostream& output, const Block<matrix_type, val_type> &block) {
+	unsigned int i,j;
+	for (i = 0; i < block.rows(); i++) {
+		output << "[ ";
+		for (j = 0; j < block.cols(); j++) {
+			output << block(i,j);
+
+			if (j < block.cols() - 1)
+				output << ", ";
+		}
+		output << " ]";
+		
+		if (block.rows() > 1 && i < block.rows() - 1)
+			output << std::endl;
+	}
+
+	return output;
+}
+
+
+}
+
+#endif /* SIMPLEMATHBLOCK_H */

src/SimpleMath/SimpleMathDynamic.h

@@ -303,6 +303,28 @@ class Matrix {
 			return result;
 		}
 
+		val_type trace() const {
+			assert (rows() == cols());
+			val_type result = 0.;
+
+			for (unsigned int i = 0; i < rows(); i++) {
+				result += operator()(i,i);
+			}
+
+			return result;
+		}
+
+		val_type mean() const {
+			assert (rows() == 1 || cols() == 1);
+
+			val_type result = 0.;
+			for (unsigned int i = 0; i < rows() * cols(); i++) {
+				result += operator[](i);
+			}
+
+			return result / static_cast<val_type>(rows() * cols());
+		}
+
 		static matrix_type Zero() {
 			matrix_type result;
 			result.setZero();
@@ -387,6 +409,38 @@ class Matrix {
 				return Block<matrix_type, val_type>(*this, row_start, col_start, row_count, col_count);
 			}
 
+		Block<matrix_type, val_type>
+			block (unsigned int row_start, unsigned int col_start, unsigned int row_count, unsigned int col_count) const {
+				return Block<matrix_type, val_type>(*this, row_start, col_start, row_count, col_count);
+			}
+
+		template <unsigned int row_count, unsigned int col_count>
+		Block<matrix_type, val_type>
+			block (unsigned int row_start, unsigned int col_start) const {
+				return Block<matrix_type, val_type>(*this, row_start, col_start, row_count, col_count);
+			}
+
+		// row and col accessors
+		Block<matrix_type, val_type>
+		col(unsigned int index) const {
+			return Block<matrix_type, val_type>(*this, 0, index, rows(), 1);
+		}
+
+		Block<matrix_type, val_type>
+		col(unsigned int index) {
+			return Block<matrix_type, val_type>(*this, 0, index, rows(), 1);
+		}
+
+		Block<matrix_type, val_type>
+		row(unsigned int index) const {
+			return Block<matrix_type, val_type>(*this, index, 0, 1, cols());
+		}
+
+		Block<matrix_type, val_type>
+		row(unsigned int index) {
+			return Block<matrix_type, val_type>(*this, index, 0, 1, cols());
+		}
+
 		// Operators with scalars
 		void operator*=(const val_type &scalar) {
 			for (unsigned int i = 0; i < nrows * ncols; i++)
@@ -450,6 +504,45 @@ class Matrix {
 			return result;
 		}
 
+		template <unsigned int _nrows, unsigned int _ncols>
+		Matrix<val_type> operator*(const Fixed::Matrix<val_type, _nrows, _ncols> &other_matrix) const {
+			assert (ncols == other_matrix.rows());
+
+			Matrix<val_type> result(nrows, other_matrix.cols());
+			
+			result.setZero();
+
+			unsigned int i,j, k;
+			for (i = 0; i < nrows; i++) {
+				for (j = 0; j < other_matrix.cols(); j++) {
+					for (k = 0; k < other_matrix.rows(); k++) {
+						result(i,j) += mData[i * ncols + k] * other_matrix(k,j);
+					}
+				}
+			}
+			
+			return result;
+		}
+
+		Matrix<val_type> operator*(const Block<matrix_type, val_type> &other_matrix) const {
+			assert (ncols == other_matrix.rows());
+
+			Matrix<val_type> result(nrows, other_matrix.cols());
+			
+			result.setZero();
+
+			unsigned int i,j, k;
+			for (i = 0; i < nrows; i++) {
+				for (j = 0; j < other_matrix.cols(); j++) {
+					for (k = 0; k < other_matrix.rows(); k++) {
+						result(i,j) += mData[i * ncols + k] * other_matrix(k,j);
+					}
+				}
+			}
+			
+			return result;
+		}
+
 		void operator*=(const Matrix &matrix) {
 			matrix_type temp (*this);
 			*this = temp * matrix;
@@ -474,12 +567,17 @@ class Matrix {
 		}
 
 		operator val_type() {
+
 			assert (nrows == 1);
 			assert (nrows == 1);
 
 			return mData[0];
 		}
 
+		Matrix operator-() const {
+			return *this * -1.0;
+		};
+
 		Matrix inverse() const {
 			return colPivHouseholderQr().inverse();
 		}

src/SimpleMath/SimpleMathDynamic.h.orig

@@ -0,0 +1,619 @@
+/**
+ * This is a highly inefficient math library. It was conceived by Martin
+ * Felis <martin.felis@iwr.uni-heidelberg.de> while he was compiling code
+ * that uses a highly efficient math library.
+ *
+ * It is intended to be used as a fast compiling substitute for the
+ * blazingly fast Eigen3 library and tries to mimic its API to a certain
+ * extend.
+ *
+ * Feel free to use it wherever you like. However, no guarantees are given
+ * that this code does what it says it would.
+ */
+
+#ifndef SIMPLEMATHDYNAMIC_H
+#define SIMPLEMATHDYNAMIC_H
+
+#include <sstream>
+#include <cstdlib>
+#include <assert.h>
+#include <algorithm>
+
+#include "compileassert.h"
+#include "SimpleMathBlock.h"
+
+/** \brief Namespace for a highly inefficient math library
+ *
+ */
+namespace SimpleMath {
+
+template <typename matrix_type>
+class LLT;
+
+template <typename matrix_type>
+class HouseholderQR;
+
+template <typename matrix_type>
+class ColPivHouseholderQR;
+
+template <typename matrix_type>
+class CommaInitializer;
+
+namespace Fixed {
+	template <typename val_type, unsigned int ncols, unsigned int nrows> class Matrix;
+}
+
+
+/** \brief Namespace for elements of varying size.
+ */
+namespace Dynamic {
+
+// forward declaration
+template <typename val_type>
+class Matrix;
+
+/** \brief Class for both matrices and vectors.
+ */
+template <typename val_type>
+class Matrix {
+	public:
+		typedef Matrix<val_type> matrix_type;
+		typedef val_type value_type;
+
+		Matrix() :
+			nrows (0),
+			ncols (0),
+			mapped_data (false),
+			mData (NULL) {};
+		Matrix(unsigned int rows) :
+			nrows (rows),
+			ncols (1),
+			mapped_data (false) {
+				mData = new val_type[rows];
+			}
+		Matrix(unsigned int rows, unsigned int cols) :
+			nrows (rows),
+			ncols (cols),
+			mapped_data (false) {
+				mData = new val_type[rows * cols];
+			}
+		Matrix(unsigned int rows, unsigned int cols, val_type *data_ptr) :
+			nrows (rows),
+			ncols (cols),
+			mapped_data (true) {
+				mData = data_ptr;
+			}
+	
+		unsigned int rows() const {
+			return nrows;
+		}
+
+		unsigned int cols() const {
+			return ncols;
+		}
+
+		unsigned int size() const {
+			return nrows * ncols;
+		}
+		void resize (unsigned int rows, unsigned int cols=1) {
+			if (nrows * ncols > 0 && mData != NULL && mapped_data == false) {
+				delete[] mData;
+			}
+
+			nrows = rows;
+			ncols = cols;
+
+			mData = new val_type[nrows * ncols];
+		}
+
+		void conservativeResize (unsigned int rows, unsigned int cols = 1) {
+			Matrix <val_type> result = Matrix<val_type>::Zero(rows, cols);
+
+			unsigned int arows = std::min (rows, nrows);
+			unsigned int acols = std::min (cols, ncols);
+
+			for (unsigned int i = 0; i < arows; i++) {
+				for (unsigned int j = 0; j < acols; j++) {
+					result(i,j) = (*this)(i,j);
+				}
+			}
+
+			*this = result;	
+		}
+
+		Matrix(const Matrix &matrix) :
+			nrows (matrix.nrows),
+			ncols (matrix.ncols),
+			mapped_data (false) {
+			unsigned int i;
+		
+			mData = new val_type[nrows * ncols];
+
+			for (i = 0; i < nrows * ncols; i++)
+				mData[i] = matrix.mData[i];
+		}
+		Matrix& operator=(const Matrix &matrix) {
+			if (this != &matrix) {
+				if (!mapped_data) {
+					delete[] mData;
+
+					nrows = matrix.nrows;
+					ncols = matrix.ncols;
+					mapped_data = false;
+
+					mData = new val_type[nrows * ncols];
+
+					unsigned int i;
+					for (i = 0; i < nrows * ncols; i++)
+						mData[i] = matrix.mData[i];
+				} else {
+					// we overwrite any existing data
+					nrows = matrix.nrows;
+					ncols = matrix.ncols;
+					mapped_data = true;
+
+					unsigned int i;
+					for (i = 0; i < nrows * ncols; i++)
+						mData[i] = matrix.mData[i];
+				}
+			}
+			return *this;
+		}
+
+		CommaInitializer<matrix_type> operator<< (const val_type& value) {
+			return CommaInitializer<matrix_type> (*this, value);
+		}
+
+		// conversion different val_types
+		template <typename other_type>
+		Matrix (const Matrix<other_type> &matrix) :
+			nrows (matrix.rows()),
+			ncols (matrix.cols()),
+			mapped_data(false) {
+
+			mData = new val_type[nrows * ncols];
+
+			for (unsigned int i = 0; i < nrows; i++) {
+				for (unsigned int j = 0; j < ncols; j++) {
+					(*this)(i,j) = static_cast<val_type>(matrix(i,j));
+				}
+			}
+		}
+
+		// conversion from a fixed size matrix
+		template <typename other_type, unsigned int fnrows, unsigned int fncols>
+		Matrix (const Fixed::Matrix<other_type, fnrows, fncols> &fixed_matrix) :
+			nrows (fnrows),
+			ncols (fncols),
+			mapped_data (false),
+			mData (NULL) {
+				mData = new val_type[nrows * ncols];
+
+				for (unsigned int i = 0; i < nrows; i++) {
+					for (unsigned int j = 0; j < ncols; j++) {
+						(*this)(i,j) = static_cast<val_type>(fixed_matrix(i,j));
+					}
+				}
+			}
+
+		template <typename other_matrix_type>
+		explicit Matrix (const Block<other_matrix_type, value_type> &block) :
+			nrows(block.rows()),
+			ncols(block.cols()),
+			mapped_data (false) {
+				mData = new val_type[nrows * ncols];
+
+				for (unsigned int i = 0; i < nrows; i++) {
+					for (unsigned int j = 0; j < ncols; j++) {
+						(*this)(i,j) = static_cast<val_type>(block(i,j));
+					}
+				}
+
+			}
+
+		~Matrix() {
+			if (nrows * ncols > 0 && mData != NULL && mapped_data == false) {
+				delete[] mData;
+				mData = NULL;
+			}
+
+			nrows = 0;
+			ncols = 0;
+		};
+
+		// comparison
+		bool operator==(const Matrix &matrix) const {
+			if (nrows != matrix.nrows || ncols != matrix.ncols)
+				return false;
+
+			for (unsigned int i = 0; i < nrows * ncols; i++) {
+				if (mData[i] != matrix.mData[i])
+					return false;
+			}
+			return true;
+		}
+		bool operator!=(const Matrix &matrix) const {
+			if (nrows != matrix.nrows || ncols != matrix.ncols)
+				return true;
+
+			for (unsigned int i = 0; i < nrows * ncols; i++) {
+				if (mData[i] != matrix.mData[i])
+					return true;
+			}
+			return false;
+		}
+
+		// access operators
+		const val_type& operator[](const unsigned int &index) const {
+			assert (index	>= 0);
+			assert (index < nrows * ncols);
+			return mData[index];
+		};
+		val_type& operator[](const unsigned int &index) {
+			assert (index	>= 0 && index < nrows * ncols);
+			return mData[index];
+		}
+
+		const val_type& operator()(const unsigned int &row, const unsigned int &col) const {
+			if (!(row	>= 0 && row < nrows && col >= 0 && col < ncols)) {
+				std::cout << "row = " << row << " col = " << col << std::endl;
+				std::cout << "nrows = " << nrows << " ncols = " << ncols << std::endl;
+				std::cout << "invalid read = " << mData[100000] << std::endl;
+			}
+			assert (row	>= 0 && row < nrows && col >= 0 && col < ncols);
+			return mData[row*ncols + col];
+		};
+		val_type& operator()(const unsigned int &row, const unsigned int &col) {
+			assert (row	>= 0 && row < nrows && col >= 0 && col < ncols);
+			return mData[row*ncols + col];
+		};
+		
+		void zero() {
+			for (unsigned int i = 0; i < ncols * nrows; i++)
+				mData[i] = 0.;
+		}
+		void setZero() {
+			zero();
+		}
+
+		val_type norm() const {
+			return sqrt(this->squaredNorm());
+		}
+
+		void normalize() {
+			val_type length = this->norm();
+
+			for (unsigned int i = 0; i < ncols * nrows; i++)
+				mData[i] /= length;
+		}
+
+		Matrix<val_type> normalized() const {
+			return Matrix<val_type> (*this) / this->norm();
+		}
+
+		Matrix<val_type> cross(const Matrix<val_type> &other_vector) {
+			assert (nrows * ncols == 3);
+			assert (other_vector.nrows * other_vector.ncols == 3);
+
+			Matrix<val_type> result (3, 1);
+			result[0] = mData[1] * other_vector[2] - mData[2] * other_vector[1];
+			result[1] = mData[2] * other_vector[0] - mData[0] * other_vector[2];
+			result[2] = mData[0] * other_vector[1] - mData[1] * other_vector[0];
+
+			return result;
+		}
+
+		static matrix_type Zero() {
+			matrix_type result;
+			result.setZero();
+			return result;
+		}
+
+		static matrix_type Zero(int rows, int cols = 1) {
+			matrix_type result (rows, cols);
+			result.setZero();
+			return result;
+		}
+
+		static matrix_type Constant (int rows, val_type value) {
+			matrix_type result (rows, 1);
+			unsigned int i;
+			for (i = 0; i < result.size(); i++)
+				result[i] = value;
+			
+			return result;
+		}
+
+		static matrix_type Constant (int rows, int cols, val_type value) {
+			matrix_type result (rows, cols);
+			unsigned int i;
+			for (i = 0; i < result.size(); i++)
+				result[i] = value;
+			
+			return result;
+		}
+
+		static matrix_type Identity (int rows, int cols = 1) {
+			assert (rows == cols);
+
+			matrix_type result (rows, cols);
+			result.identity();
+
+			return result;
+		}
+
+		void identity() {
+			assert (nrows == ncols);
+
+			setZero();
+			for (unsigned int i = 0; i < ncols; i++)
+				mData[i * ncols + i] = 1.;
+		}
+
+		void random() {
+			for (unsigned int i = 0; i < nrows * ncols; i++) 
+				mData[i] = static_cast<val_type> (rand()) / static_cast<val_type> (RAND_MAX);
+		}
+
+		val_type squaredNorm() const {
+			assert (ncols == 1 || nrows == 1);
+			val_type result = 0;
+
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				result += mData[i] * mData[i];
+
+			return result;
+		}
+
+		val_type dot(const matrix_type &matrix) const {
+			assert (ncols == 1 || nrows == 1);
+			val_type result = 0;
+
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				result += mData[i] * matrix[i];
+
+			return result;
+		}
+
+		// Blocks
+		Block<matrix_type, val_type>
+			block (unsigned int row_start, unsigned int col_start, unsigned int row_count, unsigned int col_count) {
+				return Block<matrix_type, val_type>(*this, row_start, col_start, row_count, col_count);
+			}
+
+		template <unsigned int row_count, unsigned int col_count>
+		Block<matrix_type, val_type>
+			block (unsigned int row_start, unsigned int col_start) {
+				return Block<matrix_type, val_type>(*this, row_start, col_start, row_count, col_count);
+			}
+
+		Block<matrix_type, val_type>
+			block (unsigned int row_start, unsigned int col_start, unsigned int row_count, unsigned int col_count) const {
+				return Block<matrix_type, val_type>(*this, row_start, col_start, row_count, col_count);
+			}
+
+		template <unsigned int row_count, unsigned int col_count>
+		Block<matrix_type, val_type>
+			block (unsigned int row_start, unsigned int col_start) const {
+				return Block<matrix_type, val_type>(*this, row_start, col_start, row_count, col_count);
+			}
+
+		// Operators with scalars
+		void operator*=(const val_type &scalar) {
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				mData[i] *= scalar;
+		};
+		void operator/=(const val_type &scalar) {
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				mData[i] /= scalar;
+		}
+		Matrix operator/(const val_type& scalar) const {
+			matrix_type result (*this);
+
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				result[i] /= scalar;
+
+			return result;
+		}
+
+		// Operators with other matrices
+		Matrix operator+(const Matrix &matrix) const {
+			matrix_type result (*this);
+
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				result[i] += matrix[i];
+
+			return result;
+		}
+		void operator+=(const matrix_type &matrix) {
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				mData[i] += matrix.mData[i];
+		}
+		Matrix operator-(const Matrix &matrix) const {
+			matrix_type result (*this);
+
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				result[i] -= matrix[i];
+
+			return result;
+		}
+		void operator-=(const Matrix &matrix) {
+			for (unsigned int i = 0; i < nrows * ncols; i++)
+				mData[i] -= matrix.mData[i];
+		}
+
+		Matrix<val_type> operator*(const Matrix<val_type> &other_matrix) const {
+			assert (ncols == other_matrix.nrows);
+
+			Matrix<val_type> result(nrows, other_matrix.ncols);
+			
+			result.setZero();
+
+			unsigned int i,j, k;
+			for (i = 0; i < nrows; i++) {
+				for (j = 0; j < other_matrix.cols(); j++) {
+					for (k = 0; k < other_matrix.rows(); k++) {
+						result(i,j) += mData[i * ncols + k] * other_matrix(k,j);
+					}
+				}
+			}
+			
+			return result;
+		}
+
+		template <unsigned int _nrows, unsigned int _ncols>
+		Matrix<val_type> operator*(const Fixed::Matrix<val_type, _nrows, _ncols> &other_matrix) const {
+			assert (ncols == other_matrix.rows());
+
+			Matrix<val_type> result(nrows, other_matrix.cols());
+			
+			result.setZero();
+
+			unsigned int i,j, k;
+			for (i = 0; i < nrows; i++) {
+				for (j = 0; j < other_matrix.cols(); j++) {
+					for (k = 0; k < other_matrix.rows(); k++) {
+						result(i,j) += mData[i * ncols + k] * other_matrix(k,j);
+					}
+				}
+			}
+			
+			return result;
+		}
+
+		Matrix<val_type> operator*(const Block<matrix_type, val_type> &other_matrix) const {
+			assert (ncols == other_matrix.rows());
+
+			Matrix<val_type> result(nrows, other_matrix.cols());
+			
+			result.setZero();
+
+			unsigned int i,j, k;
+			for (i = 0; i < nrows; i++) {
+				for (j = 0; j < other_matrix.cols(); j++) {
+					for (k = 0; k < other_matrix.rows(); k++) {
+						result(i,j) += mData[i * ncols + k] * other_matrix(k,j);
+					}
+				}
+			}
+			
+			return result;
+		}
+
+		void operator*=(const Matrix &matrix) {
+			matrix_type temp (*this);
+			*this = temp * matrix;
+		}
+
+		// Special operators
+		val_type *data(){
+			return mData;
+		}
+
+		// regular transpose of a 6 dimensional matrix
+		Matrix<val_type> transpose() const {
+			Matrix<val_type> result(ncols, nrows);
+	
+			for (unsigned int i = 0; i < nrows; i++) {
+				for (unsigned int j = 0; j < ncols; j++) {
+					result(j,i) = mData[i * ncols + j];
+				}
+			}
+
+			return result;
+		}
+
+		operator val_type() {
+			assert (nrows == 1);
+			assert (nrows == 1);
+
+			return mData[0];
+		}
+
+		Matrix inverse() const {
+			return colPivHouseholderQr().inverse();
+		}
+
+		const LLT<matrix_type> llt() const {
+			return LLT<matrix_type>(*this);
+		}
+
+		const HouseholderQR<matrix_type> householderQr() const {
+			return HouseholderQR<matrix_type>(*this);
+		}
+		const ColPivHouseholderQR<matrix_type> colPivHouseholderQr() const {
+			return ColPivHouseholderQR<matrix_type>(*this);
+		}
+
+	private:
+		unsigned int nrows;
+		unsigned int ncols;
+		bool mapped_data;
+
+		val_type* mData;
+};
+
+template <typename val_type>
+inline Matrix<val_type> operator*(val_type scalar, const Matrix<val_type> &matrix) {
+	Matrix<val_type> result (matrix);
+
+	for (unsigned int i = 0; i < matrix.rows() * matrix.cols(); i++)
+		result.data()[i] *= scalar;
+
+	return result;
+}
+
+template <typename val_type, typename other_type>
+inline Matrix<val_type> operator*(const Matrix<val_type> &matrix, other_type scalar) {
+	Matrix<val_type> result (matrix);
+
+	for (unsigned int i = 0; i < matrix.rows() * matrix.cols(); i++)
+		result.data()[i] *= static_cast<val_type>(scalar);
+
+	return result;
+}
+
+template <typename val_type>
+inline std::ostream& operator<<(std::ostream& output, const Matrix<val_type> &matrix) {
+	size_t max_width = 0;
+	size_t out_width = output.width();
+
+	// get the widest number
+	for (size_t i = 0; i < matrix.rows(); i++) {
+		for (size_t j = 0; j < matrix.cols(); j++) {
+			std::stringstream out_stream;
+			out_stream << matrix(i,j);
+			max_width = std::max (out_stream.str().size(),max_width);
+		}
+	}
+
+	// overwrite width if it was explicitly prescribed
+	if (out_width != 0) {
+		max_width = out_width;
+	}
+
+	for (unsigned int i = 0; i < matrix.rows(); i++) {
+		output.width(0);
+		output << "[ ";
+		output.width(out_width);
+		for (unsigned int j = 0; j < matrix.cols(); j++) {
+			std::stringstream out_stream;
+			out_stream.width (max_width);
+			out_stream << matrix(i,j);
+			output << out_stream.str();
+
+			if (j < matrix.cols() - 1)
+				output << ", ";
+		}
+		output << " ]";
+		
+		if (matrix.rows() > 1 && i < matrix.rows() - 1)
+			output << std::endl;
+	}
+	return output;}
+
+}
+
+}
+
+#endif /* SIMPLEMATHDYNAMIC_H */

src/SimpleMath/SimpleMathFixed.h

@@ -78,13 +78,10 @@ class Matrix {
 			for (i = 0; i < nrows * ncols; i++)
 				mData[i] = matrix.mData[i];
 		}
-		Matrix(unsigned int rows, unsigned int cols, val_type *data_ptr) {
+		Matrix(unsigned int _nrows, unsigned int _ncols, const value_type* values) {
-			assert (rows == nrows);
+			assert(nrows == _nrows);
-			assert (cols == ncols);
+			assert(ncols == _ncols);
-
+			memcpy (mData, values, sizeof(value_type) * nrows * ncols);
-			for (int i = 0; i < 16; i++) {
-				mData[i] = data_ptr[i];
-			}
 		}
 
 		Matrix& operator=(const Matrix &matrix) {
@@ -529,6 +526,28 @@ class Matrix {
 			return result;
 		}
 
+		val_type trace() const {
+			COMPILE_ASSERT(nrows == ncols);
+			val_type result = 0.;
+
+			for (unsigned int i = 0; i < rows(); i++) {
+				result += operator()(i,i);
+			}
+
+			return result;
+		}
+
+		val_type mean() const {
+			COMPILE_ASSERT(nrows == 1 || ncols == 1);
+
+			val_type result = 0.;
+			for (unsigned int i = 0; i < rows() * cols(); i++) {
+				result += operator[](i);
+			}
+
+			return result / static_cast<val_type>(nrows * ncols);
+		}
+
 		static matrix_type Zero() {
 			matrix_type result;
 			result.setZero();
@@ -616,6 +635,27 @@ class Matrix {
 				return Block<matrix_type, val_type>(*this, row_start, col_start, block_row_count, block_col_count);
 			}
 
+		// row and col accessors
+		Block<matrix_type, val_type>
+		col(unsigned int index) const {
+			return Block<matrix_type, val_type>(*this, 0, index, rows(), 1);
+		}
+
+		Block<matrix_type, val_type>
+		col(unsigned int index) {
+			return Block<matrix_type, val_type>(*this, 0, index, rows(), 1);
+		}
+
+		Block<matrix_type, val_type>
+		row(unsigned int index) const {
+			return Block<matrix_type, val_type>(*this, index, 0, 1, cols());
+		}
+
+		Block<matrix_type, val_type>
+		row(unsigned int index) {
+			return Block<matrix_type, val_type>(*this, index, 0, 1, cols());
+		}
+
 		// Operators with scalars
 		void operator*=(const val_type &scalar) {
 			for (unsigned int i = 0; i < nrows * ncols; i++)
@@ -701,7 +741,6 @@ class Matrix {
 			return result;
 		}
 
-
 		void operator*=(const Matrix &matrix) {
 			matrix_type temp (*this);
 			*this = temp * matrix;

src/SimpleMath/SimpleMathQR.h

@@ -233,7 +233,7 @@ namespace SimpleMath {
 					MatrixXXd Q (MatrixXXd::Identity(mR.rows(), mR.rows()));
 
 					Q.block(i, i, block_rows, block_rows) = MatrixXXd (Q.block(i, i, block_rows, block_rows))
-						- MatrixXXd(v * v.transpose() / (v.squaredNorm() * 0.5));
+						- MatrixXXd(v * v.transpose() / (v.squaredNorm() * static_cast<value_type>(0.5)));
 
 					mR = Q * mR;
 

src/TestModule.cc

@@ -1,11 +1,63 @@
 #include "RuntimeModule.h"
+#include "Globals.h"
 #include "Renderer.h"
 #include "3rdparty/ocornut-imgui/imgui.h"
 #include "imgui/imgui.h"
+#include <GLFW/glfw3.h>
+#include "SimpleMath/SimpleMath.h"
+#include "SimpleMath/SimpleMathMap.h"
 
 #include <iostream>
 #include <sstream>
 
+typedef SimpleMath::Matrix44f Matrix44f;
+typedef SimpleMath::Vector4f Vector4f;
+typedef SimpleMath::Matrix33f Matrix33f;
+typedef SimpleMath::Vector3f Vector3f;
+typedef SimpleMath::MatrixNNf MatrixNNf;
+typedef SimpleMath::VectorNf VectorNf;
+
+
+void handle_keyboard () {
+	Camera *active_camera = &gRenderer->cameras[gRenderer->activeCameraIndex];
+	assert (active_camera != nullptr);
+	Matrix44f camera_view_matrix = SimpleMath::Map<Matrix44f>(active_camera->mtxView, 4, 4);
+	Matrix33f camera_rot_inv = camera_view_matrix.block<3,3>(0,0).transpose();
+
+	Vector3f forward = camera_rot_inv.transpose() * Vector3f (0.f, 0.f, 1.f);
+	Vector3f right = camera_rot_inv.transpose() * Vector3f (1.f, 0.f, 0.f);
+	
+	Vector3f eye = SimpleMath::Map<Vector3f>(active_camera->eye, 3, 1);
+	Vector3f poi= SimpleMath::Map<Vector3f>(active_camera->poi, 3, 1);
+
+	Vector3f direction (0.f, 0.f, 0.f);
+
+	if (glfwGetKey(gWindow, GLFW_KEY_W) == GLFW_PRESS) {
+		direction += forward;
+	} 
+	
+	if (glfwGetKey(gWindow, GLFW_KEY_S) == GLFW_PRESS) {
+		direction -= forward;
+	}
+	
+	if (glfwGetKey(gWindow, GLFW_KEY_D) == GLFW_PRESS) {
+		direction += right;
+	} 
+	
+	if (glfwGetKey(gWindow, GLFW_KEY_A) == GLFW_PRESS) {
+		direction -= right;
+	}
+
+	float step = 0.1f;
+	eye += direction * step;
+	poi += direction * step;
+
+	memcpy (active_camera->eye, eye.data(), sizeof(float) * 3);
+	memcpy (active_camera->poi, poi.data(), sizeof(float) * 3);
+}
+
+// Boilerplate for the module reload stuff
+
 struct module_state {
 	int width, height;
 	int select;
@@ -33,8 +85,13 @@ static void module_unload(struct module_state *state) {
 
 static bool module_step(struct module_state *state) {
 	bool enabled = true;
-	ImGui::Begin("yoyoyo");
+	ImGui::Begin("yoyoyoxi2");
-	if (ImGui::Button("Baem Yahoo")) {
+	if (ImGui::Button("Hallo Katrina")) {
+		if (gRenderer->drawDebug) {
+			gRenderer->drawDebug = false;
+		} else {
+			gRenderer->drawDebug = true;
+		}
 		std::cout << "Clicked on Baem!" << std::endl;
 	}
 	ImGui::End();
@@ -43,6 +100,8 @@ static bool module_step(struct module_state *state) {
 	std::ostringstream s;
 	s << "TestModule:  2 Runtime Object 4 " << deltaTime << " update called!";
 
+	handle_keyboard();
+
 	bgfx::dbgTextPrintf(1, 20, 0x6f, s.str().c_str());
 
 	return true;

src/main.cc

@@ -1,39 +1,3 @@
-//========================================================================
-// Simple GLFW example
-// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//    claim that you wrote the original software. If you use this software
-//    in a product, an acknowledgment in the product documentation would
-//    be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such, and must not
-//    be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source
-//    distribution.
-//
-//========================================================================
-//! [code]
-
-//#define USE_GLAD
-
-#ifdef USE_GLEW
-#include <GL/glew.h>
-#endif
-
-#ifdef USE_GLAD
-#include <glad/glad.h>
-#endif
-
 #define GLFW_EXPOSE_NATIVE_GLX
 #define GLFW_EXPOSE_NATIVE_X11
 #include <GLFW/glfw3.h>
@@ -51,37 +15,12 @@
 #include "Renderer.h"
 #include "RuntimeModuleManager.h"
 
+#include "Globals.h"
+Renderer* gRenderer = nullptr;
+GLFWwindow* gWindow = nullptr;
+
 using namespace std;
 
-static const struct
-{
-    float x, y;
-    float r, g, b;
-} vertices[3] =
-{
-    { -0.6f, -0.4f, 1.f, 0.f, 0.f },
-    {  0.6f, -0.4f, 0.f, 1.f, 0.f },
-    {   0.f,  0.6f, 0.f, 0.f, 1.f }
-};
-
-static const char* vertex_shader_text =
-"uniform mat4 MVP;\n"
-"attribute vec3 vCol;\n"
-"attribute vec2 vPos;\n"
-"varying vec3 color;\n"
-"void main()\n"
-"{\n"
-"    gl_Position = MVP * vec4(vPos, 0.0, 1.0);\n"
-"    color = vCol;\n"
-"}\n";
-
-static const char* fragment_shader_text =
-"varying vec3 color;\n"
-"void main()\n"
-"{\n"
-"    gl_FragColor = vec4(color, 1.0);\n"
-"}\n";
-
 namespace bgfx {
 	inline void glfwSetWindow(GLFWwindow* _window)
 	{
@@ -127,17 +66,19 @@ int main(void)
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_ANY_PROFILE);
 
-	GLFWwindow* win = glfwCreateWindow(800, 600, "ProtoT", NULL, NULL);
+	gWindow = glfwCreateWindow(800, 600, "ProtoT", NULL, NULL);
-	glfwMakeContextCurrent(win);
+	glfwMakeContextCurrent(gWindow);
 	int width, height;
-	glfwGetWindowSize(win, &width, &height);
+	glfwGetWindowSize(gWindow, &width, &height);
 
 	Renderer renderer;
-	bgfx::glfwSetWindow(win);
+	bgfx::glfwSetWindow(gWindow);
 	bgfx::renderFrame();
 
 	renderer.initialize(width, height);
 
+	gRenderer = &renderer;
+	
 //	bgfx::init();
 //	bgfx::reset(width, height, BGFX_RESET_VSYNC);
 
@@ -154,10 +95,10 @@ int main(void)
 	module_manager.RegisterModule("libTestModule.so");
 
 	printf("Starting main loop...\n");
-	glfwSetKeyCallback(win, key_callback);
+	glfwSetKeyCallback(gWindow, key_callback);
 	int64_t time_offset = bx::getHPCounter();
 
-	while(!glfwWindowShouldClose(win)) {
+	while(!glfwWindowShouldClose(gWindow)) {
 		int64_t now = bx::getHPCounter();
 		static int64_t last = now;
 		const int64_t frameTime = now - last;
@@ -168,7 +109,7 @@ int main(void)
 		float time = (float)( (now-time_offset)/double(bx::getHPFrequency() ) );
 
 		int width, height;
-		glfwGetWindowSize(win, &width, &height);
+		glfwGetWindowSize(gWindow, &width, &height);
 		if (width != renderer.width || height != renderer.height) {
 			renderer.resize(width, height);
 		}
@@ -192,18 +133,20 @@ int main(void)
 
 		// send inputs to the input state of the renderer
 		double mouse_x, mouse_y;
-		glfwGetCursorPos(win, &mouse_x, &mouse_y);
+		glfwGetCursorPos(gWindow, &mouse_x, &mouse_y);
 		renderer.inputState.mouseX = mouse_x;
 		renderer.inputState.mouseY = mouse_y;
 		renderer.inputState.mouseButton =
-			glfwGetMouseButton(win, 0)
+			glfwGetMouseButton(gWindow, 0)
-			+ (glfwGetMouseButton(win, 1) << 1)
+			+ (glfwGetMouseButton(gWindow, 1) << 1)
-			+ (glfwGetMouseButton(win, 2) << 2);
+			+ (glfwGetMouseButton(gWindow, 2) << 2);
 
     usleep(16000);
 	}
 
 	module_manager.UnloadModules();
+
+	gRenderer = nullptr;
 }
 
 //! [code]