Adding clang format with my style based on google

33 files changed, 1941 insertions, 1674 deletions

diff --git a/.clang-format b/.clang-format
index 83ab45c9..3bf5128c 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,23 +1,23 @@
 ---
 Language:        Cpp
-BasedOnStyle:  LLVM
-AccessModifierOffset: -2
+BasedOnStyle:  Google
+AccessModifierOffset: -4
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
-AlignEscapedNewlinesLeft: false
+AlignEscapedNewlinesLeft: true
 AlignOperands:   true
 AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
 AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: false
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: true
 BinPackArguments: true
 BinPackParameters: true
 BraceWrapping:   
@@ -40,7 +40,7 @@ BreakAfterJavaFieldAnnotations: false
 BreakStringLiterals: true
 ColumnLimit:     80
 CommentPragmas:  '^ IWYU pragma:'
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
@@ -49,33 +49,31 @@ DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
 ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
 IncludeCategories: 
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+  - Regex:           '^<.*'
     Priority:        2
-  - Regex:           '^(<|"(gtest|isl|json)/)'
-    Priority:        3
   - Regex:           '.*'
-    Priority:        1
-IncludeIsMainRegex: '$'
-IndentCaseLabels: false
-IndentWidth:     2
+    Priority:        3
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IndentCaseLabels: true
+IndentWidth:     4
 IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
+KeepEmptyLinesAtTheStartOfBlocks: false
 MacroBlockBegin: ''
 MacroBlockEnd:   ''
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
-ObjCBlockIndentWidth: 2
+ObjCBlockIndentWidth: 4
 ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakBeforeFirstCallParameter: 19
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Right
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
 ReflowComments:  true
 SortIncludes:    true
 SpaceAfterCStyleCast: false
@@ -83,13 +81,13 @@ SpaceAfterTemplateKeyword: true
 SpaceBeforeAssignmentOperators: true
 SpaceBeforeParens: ControlStatements
 SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
+SpacesBeforeTrailingComments: 2
 SpacesInAngles:  false
 SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp14
+Standard:        Auto
 TabWidth:        4
 UseTab:          Never
 ...
diff --git a/include/YAGE/Math/matrix.hpp b/include/YAGE/Math/matrix.hpp
index 8f490b41..860a250c 100644
--- a/include/YAGE/Math/matrix.hpp
+++ b/include/YAGE/Math/matrix.hpp
@@ -6,18 +6,16 @@
  * ----------------------------------------------------------------------------
  */
 
-
 /** \file matrix.hpp Templated matrix class
- * 
+ *
  * Matrix
  * ======
  *
  * This is a very general matrix class that can then be inherited by
- * vectors and other similar data structures to minimize code 
+ * vectors and other similar data structures to minimize code
  * density.
  */
 
-
 #ifndef YAGE_MATH_MATRIX_HPP
 #define YAGE_MATH_MATRIX_HPP
 
@@ -28,21 +26,19 @@
 #include <string>
 #include <vector>
 
+namespace yage {
 
-namespace yage
-{
-
-template<int Rows, int Cols, class Type> class Matrix;
+template <int Rows, int Cols, class Type>
+class Matrix;
 
 /** \internal Namespace for internal details.
- * 
+ *
  * Detail Namespace
  * ================
  *
  * This is the namespace used for implementation detail.
  */
-namespace detail
-{
+namespace detail {
 
 /** \internal Internal Row class used by the Matrix class to return the
  * internal data structure of the Matrix.
@@ -52,30 +48,27 @@ namespace detail
  *
  * Internal Row class to return a value in the row of the matrix.
  */
-template<int Rows, int Cols, class Type> class Row
-{
+template <int Rows, int Cols, class Type>
+class Row {
 private:
-	Matrix<Rows, Cols, Type> *parent_;
-	int index_;
+    Matrix<Rows, Cols, Type>* parent_;
+    int index_;
 
 public:
-	Row<Rows, Cols, Type>(Matrix<Rows, Cols, Type> *parent, int index) :
-		parent_(parent), index_(index)
-	{}
-
-	Type& operator[](int col)
-	{
-		// the index is the y-position of the element in the matrix
-		return parent_->data_[index_*Cols+col];
-	}
-
-	const Type& operator[](int col) const
-	{
-		return parent_->data_[index_*Cols+col];
-	}
+    Row<Rows, Cols, Type>(Matrix<Rows, Cols, Type>* parent, int index)
+        : parent_(parent), index_(index) {}
+
+    Type& operator[](int col) {
+        // the index is the y-position of the element in the matrix
+        return parent_->data_[index_ * Cols + col];
+    }
+
+    const Type& operator[](int col) const {
+        return parent_->data_[index_ * Cols + col];
+    }
 };
 
-} // detail
+}  // detail
 
 /** Base Matrix class used by other similar classes.
  *
@@ -85,365 +78,297 @@ public:
  * This is the base matrix class that can be used by all the other matrix
  * like data structures.
  */
-template<int Rows=4, int Cols=4, class Type=double> class Matrix
-{
-	// friended with the row class so that it can access protected member data
-	friend class detail::Row<Rows, Cols, Type>;
+template <int Rows = 4, int Cols = 4, class Type = double>
+class Matrix {
+    // friended with the row class so that it can access protected member data
+    friend class detail::Row<Rows, Cols, Type>;
+
 protected:
-	/// Vector containing the data of the matrix
-	std::vector<Type> data_;
+    /// Vector containing the data of the matrix
+    std::vector<Type> data_;
 
 public:
-	/// Initializes the size of the data_ vector
-	Matrix<Rows, Cols, Type>() : data_(Rows*Cols) {}
-	Matrix<Rows, Cols, Type>(const std::vector<Type>& data) : data_(data) {}
-
-	/// Returns the row size of the Matrix
-	int rowSize() const
-	{
-		return Rows;
-	}
-
-	/// Returns the column size of the Matrixxs
-	int colSize() const
-	{
-		return Cols;
-	}
-
-	/** Return the row specified row as a Matrix with only one row
-	 *
-	 * \param[in] row Row number to be returned
-	 *
-	 * Returns the row that is specified by the row variables.
-	 */
-	Matrix<1, Cols, Type> getRow(int row) const
-	{
-		Matrix<1, Cols, Type> rowMatrix;
-		for(int i=0; i<Cols; ++i)
-		{
-			rowMatrix[0][i]=data_[row][i];
-		}
-		return rowMatrix;
-	}
-
-	// returns the column in a column matrix
-	Matrix<Rows, 1, Type> getCol(int col) const
-	{
-		Matrix<Rows, 1, Type> colMatrix;
-		for(int i=0; i<Rows; ++i)
-		{
-			colMatrix[i][0]=data_[i][col];
-		}
-		return colMatrix;
-	}
-
-	// iterator support for begin
-	typename std::vector<Type>::iterator begin()
-	{
-		return data_.begin();
-	}
-
-	// iterator support for end
-	typename std::vector<Type>::iterator end()
-	{
-		return data_.end();
-	}
-
-	// prints out the matrix, but can also be implemented by other classes to print data
-	// differently
-	virtual std::string toString() const
-	{
-		std::stringstream ss;
-		ss<<'[';
-		for(int i=0; i<Rows-1; ++i)
-		{
-			ss<<'[';
-			for(int j=0; j<Cols-1; ++j)
-			{
-				ss<<data_[i*Cols+j]<<' ';
-			}
-			ss<<data_[(Rows-1)*Cols+Cols-1]<<"],";
-		}
-		ss<<'[';
-		for(int j=0; j<Cols-1; ++j)
-		{
-			ss<<data_[(Rows-1)*Cols+j]<<' ';
-		}
-		ss<<data_[(Rows-1)*Cols+Cols-1]<<"]]";
-		return ss.str();
-	}
-
-	detail::Row<Rows, Cols, Type> operator[](int row)
-	{
-		return detail::Row<Rows, Cols, Type>(this, row);
-	}
-
-	detail::Row<Rows, Cols, Type> operator[](int row) const
-	{
-		// TODO got to fix this
-		return detail::Row<Rows, Cols, Type>((Matrix<Rows, Cols, Type>*)this, row);
-	}
-
-	Matrix<Rows, Cols, Type>& operator+=(const Matrix<Rows, Cols, Type> &rhs)
-	{
-		std::vector<Type> out;
-		out.reserve(data_.size());
-		std::transform(data_.begin(), data_.end(), rhs.data_.begin(), std::back_inserter(out),
-		               [] (Type a, Type b) {
-			               return a+b;
-		               });
-		data_=std::move(out);
-		return *this;
-	}
-
-	Matrix<Rows, Cols, Type>& operator-=(const Matrix<Rows, Cols, Type> &rhs)
-	{
-		std::vector<Type> out;
-		out.reserve(data_.size());
-		std::transform(data_.begin(), data_.end(), rhs.begin(), std::back_inserter(out),
-		               [] (Type a, Type b) {
-			               return a-b;
-		               });
-		data_=std::move(out);
-		return *this;
-	}
+    /// Initializes the size of the data_ vector
+    Matrix<Rows, Cols, Type>() : data_(Rows * Cols) {}
+    Matrix<Rows, Cols, Type>(const std::vector<Type>& data) : data_(data) {}
+
+    /// Returns the row size of the Matrix
+    int rowSize() const { return Rows; }
+
+    /// Returns the column size of the Matrixxs
+    int colSize() const { return Cols; }
+
+    /** Return the row specified row as a Matrix with only one row
+   *
+   * \param[in] row Row number to be returned
+   *
+   * Returns the row that is specified by the row variables.
+   */
+    Matrix<1, Cols, Type> getRow(int row) const {
+        Matrix<1, Cols, Type> rowMatrix;
+        for (int i = 0; i < Cols; ++i) {
+            rowMatrix[0][i] = data_[row][i];
+        }
+        return rowMatrix;
+    }
+
+    // returns the column in a column matrix
+    Matrix<Rows, 1, Type> getCol(int col) const {
+        Matrix<Rows, 1, Type> colMatrix;
+        for (int i = 0; i < Rows; ++i) {
+            colMatrix[i][0] = data_[i][col];
+        }
+        return colMatrix;
+    }
+
+    // iterator support for begin
+    typename std::vector<Type>::iterator begin() { return data_.begin(); }
+
+    // iterator support for end
+    typename std::vector<Type>::iterator end() { return data_.end(); }
+
+    // prints out the matrix, but can also be implemented by other classes to
+    // print data differently
+    virtual std::string toString() const {
+        std::stringstream ss;
+        ss << '[';
+        for (int i = 0; i < Rows - 1; ++i) {
+            ss << '[';
+            for (int j = 0; j < Cols - 1; ++j) {
+                ss << data_[i * Cols + j] << ' ';
+            }
+            ss << data_[(Rows - 1) * Cols + Cols - 1] << "],";
+        }
+        ss << '[';
+        for (int j = 0; j < Cols - 1; ++j) {
+            ss << data_[(Rows - 1) * Cols + j] << ' ';
+        }
+        ss << data_[(Rows - 1) * Cols + Cols - 1] << "]]";
+        return ss.str();
+    }
+
+    detail::Row<Rows, Cols, Type> operator[](int row) {
+        return detail::Row<Rows, Cols, Type>(this, row);
+    }
+
+    detail::Row<Rows, Cols, Type> operator[](int row) const {
+        // TODO got to fix this
+        return detail::Row<Rows, Cols, Type>((Matrix<Rows, Cols, Type>*)this,
+                                             row);
+    }
+
+    Matrix<Rows, Cols, Type>& operator+=(const Matrix<Rows, Cols, Type>& rhs) {
+        std::vector<Type> out;
+        out.reserve(data_.size());
+        std::transform(data_.begin(), data_.end(), rhs.data_.begin(),
+                       std::back_inserter(out),
+                       [](Type a, Type b) { return a + b; });
+        data_ = std::move(out);
+        return *this;
+    }
+
+    Matrix<Rows, Cols, Type>& operator-=(const Matrix<Rows, Cols, Type>& rhs) {
+        std::vector<Type> out;
+        out.reserve(data_.size());
+        std::transform(data_.begin(), data_.end(), rhs.begin(),
+                       std::back_inserter(out),
+                       [](Type a, Type b) { return a - b; });
+        data_ = std::move(out);
+        return *this;
+    }
 };
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
-{
-	lhs+=rhs;
-	return lhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const Matrix<M, N, T>& rhs) {
+    lhs += rhs;
+    return lhs;
 }
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const Matrix<M, N, T> &rhs)
-{
-	lhs-=rhs;
-	return lhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const Matrix<M, N, T>& rhs) {
+    lhs -= rhs;
+    return lhs;
 }
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const T &rhs)
-{
-	for(auto &data : lhs)
-	{
-		data+=rhs;
-	}
-	return lhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator+(Matrix<M, N, T> lhs, const T& rhs) {
+    for (auto& data : lhs) {
+        data += rhs;
+    }
+    return lhs;
 }
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator+(const T &lhs, Matrix<M, N, T> rhs)
-{
-	for(auto &data : rhs)
-	{
-		data+=lhs;
-	}
-	return rhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator+(const T& lhs, Matrix<M, N, T> rhs) {
+    for (auto& data : rhs) {
+        data += lhs;
+    }
+    return rhs;
 }
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const T &rhs)
-{
-	for(auto &data : lhs)
-	{
-		data-=rhs;
-	}
-	return lhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator-(Matrix<M, N, T> lhs, const T& rhs) {
+    for (auto& data : lhs) {
+        data -= rhs;
+    }
+    return lhs;
 }
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator-(const T &lhs, Matrix<M, N, T> rhs)
-{
-	for(auto &data : rhs)
-	{
-		data=lhs-data;
-	}
-	return rhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator-(const T& lhs, Matrix<M, N, T> rhs) {
+    for (auto& data : rhs) {
+        data = lhs - data;
+    }
+    return rhs;
 }
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator*(Matrix<M, N, T> lhs, const T &rhs)
-{
-	for(auto &data : lhs)
-	{
-		data*=rhs;
-	}
-	return lhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator*(Matrix<M, N, T> lhs, const T& rhs) {
+    for (auto& data : lhs) {
+        data *= rhs;
+    }
+    return lhs;
 }
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator*(const T &lhs, Matrix<M, N, T> rhs) {
-	for(auto &data : rhs)
-	{
-		data*=lhs;
-	}
-	return rhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator*(const T& lhs, Matrix<M, N, T> rhs) {
+    for (auto& data : rhs) {
+        data *= lhs;
+    }
+    return rhs;
 }
 
-template<int M, int N, class T>
-Matrix<M, N, T> operator/(Matrix<M, N, T> lhs, const T &rhs)
-{
-	for(auto &data : lhs)
-	{
-		data/=rhs;
-	}
-	return lhs;
+template <int M, int N, class T>
+Matrix<M, N, T> operator/(Matrix<M, N, T> lhs, const T& rhs) {
+    for (auto& data : lhs) {
+        data /= rhs;
+    }
+    return lhs;
 }
 
-template<int M, int N, class T>
-bool operator==(const Matrix<M, N, T> &lhs, const Matrix<M, N, T> &rhs)
-{
-	for(int i=0; i<M; ++i)
-		for(int j=0; j<N; ++j)
-			if(lhs[i][j]!=rhs[i][j])
-					return false;
-	return true;
+template <int M, int N, class T>
+bool operator==(const Matrix<M, N, T>& lhs, const Matrix<M, N, T>& rhs) {
+    for (int i = 0; i < M; ++i)
+        for (int j = 0; j < N; ++j)
+            if (lhs[i][j] != rhs[i][j]) return false;
+    return true;
 }
 
-template<int M, int N, class T>
-std::ostream& operator<<(std::ostream &os, const Matrix<M, N, T> &mat)
-{
-	return os<<mat.toString();
+template <int M, int N, class T>
+std::ostream& operator<<(std::ostream& os, const Matrix<M, N, T>& mat) {
+    return os << mat.toString();
 }
 
-template<int Rows=2, class Type=double> class Vector : public Matrix<Rows, 1, Type>
-{
+template <int Rows = 2, class Type = double>
+class Vector : public Matrix<Rows, 1, Type> {
 public:
-	Vector<Rows, Type>() : Matrix<Rows, 1, Type>() {}
-	Vector<Rows, Type>(const Matrix<Rows, 1, Type>& other) : Matrix<Rows, 1, Type>(other) {}
-	Vector<Rows, Type>(const std::vector<Type>& data) : Matrix<Rows, 1, Type>(data) {}
-
-	Type& operator[](int col)
-	{
-		return this->data_[col];
-	}
-
-	const Type& operator[](int col) const
-	{
-		return this->data_[col];
-	}
-
-	virtual std::string toString() const
-	{
-		std::stringstream ss;
-		ss<<"[";
-		for(std::size_t i=0; i<this->data_.size()-1; ++i)
-		{
-			ss<<this->data_[i]<<" ";
-		}
-		ss<<this->data_[this->data_.size()-1]<<"]";
-		return ss.str();
-	}
+    Vector<Rows, Type>() : Matrix<Rows, 1, Type>() {}
+    Vector<Rows, Type>(const Matrix<Rows, 1, Type>& other)
+        : Matrix<Rows, 1, Type>(other) {}
+    Vector<Rows, Type>(const std::vector<Type>& data)
+        : Matrix<Rows, 1, Type>(data) {}
+
+    Type& operator[](int col) { return this->data_[col]; }
+
+    const Type& operator[](int col) const { return this->data_[col]; }
+
+    virtual std::string toString() const {
+        std::stringstream ss;
+        ss << "[";
+        for (std::size_t i = 0; i < this->data_.size() - 1; ++i) {
+            ss << this->data_[i] << " ";
+        }
+        ss << this->data_[this->data_.size() - 1] << "]";
+        return ss.str();
+    }
 };
 
 /** 2D Vector class.
  *
  * Two dimensional vector class.
  */
-template<class Type=double> class Vector2 : public Vector<2, Type>
-{
+template <class Type = double>
+class Vector2 : public Vector<2, Type> {
 public:
-	Vector2<Type>() : Vector<2, Type>() {}
-	Vector2<Type>(const std::vector<Type>& data) : Vector<2, Type>(data) {}
-	
-	Vector2<Type>(Type x, Type y)
-	{
-		this->data_[0]=x;
-		this->data_[1]=y;
-	}
-	
-	Vector2<Type>(const Matrix<2, 1, Type> &other) : Vector<2, Type>(other) {} 
-
-	Type& x()
-	{
-		return this->data_[0];
-	}
-
-	const Type& x() const
-	{
-		return this->data_[0];
-	}
-	
-	Type& y()
-	{
-		return this->data_[1];
-	}
-
-	const Type& y() const
-	{
-		return this->data_[1];
-	}	
+    Vector2<Type>() : Vector<2, Type>() {}
+    Vector2<Type>(const std::vector<Type>& data) : Vector<2, Type>(data) {}
+
+    Vector2<Type>(Type x, Type y) {
+        this->data_[0] = x;
+        this->data_[1] = y;
+    }
+
+    Vector2<Type>(const Matrix<2, 1, Type>& other) : Vector<2, Type>(other) {}
+
+    Type& x() { return this->data_[0]; }
+
+    const Type& x() const { return this->data_[0]; }
+
+    Type& y() { return this->data_[1]; }
+
+    const Type& y() const { return this->data_[1]; }
 };
 
 /// Definition of a 2D vector.
 typedef Vector2<double> Vector2d;
 
 /** Namespace containing functions that operate on matrices. */
-namespace matrix
-{
+namespace matrix {
 
 /** Transposes a matrix and returns the result
- *
- * \param[in] m input matrix.
- */
-template<int M, int N, class T> Matrix<N, M, T> transpose(const Matrix<M, N, T> &m)
-{
-	Matrix<N, M, T> trans;
-	for(int i=0; i<M; ++i)
-	{
-		for(int j=0; j<N; ++j)
-		{
-			trans[j][i]=m[i][j];
-		}
-	}
-	return trans;
+*
+* \param[in] m input matrix.
+*/
+template <int M, int N, class T>
+Matrix<N, M, T> transpose(const Matrix<M, N, T>& m) {
+    Matrix<N, M, T> trans;
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            trans[j][i] = m[i][j];
+        }
+    }
+    return trans;
 }
 
 /** Returns the dot product between two vectors
- *
- * \param[in] m1,m2 Input matrices.
- */
-template<int R, class T> T dot(const Matrix<R, 1, T> &m1, const Matrix<R, 1, T> &m2)
-{
-	T sum=0;
-	for(int i=0; i<R; ++i)
-	{
-		sum += m1[i][0]*m2[i][0];
-	}
-	return sum;
+*
+* \param[in] m1,m2 Input matrices.
+*/
+template <int R, class T>
+T dot(const Matrix<R, 1, T>& m1, const Matrix<R, 1, T>& m2) {
+    T sum = 0;
+    for (int i = 0; i < R; ++i) {
+        sum += m1[i][0] * m2[i][0];
+    }
+    return sum;
 }
 
 /** Multiplies two matrices together.
- *
- * \param[in] m1,m2 Matrix inputs
- *
- * Requires the two matrices to be compatible with multiplication.
- */
-template<int M, int N, int P, int Q, class T>
-Matrix<M, Q, T> multiply(const Matrix<M, N, T> &m1, const Matrix<P, Q, T> &m2)
-{
-	if(N!=P)
-	{
-		throw std::runtime_error("Matrices don't have the right dimensions for multiplication");
-	}
-	
-	Matrix<M, Q, T> res;
-
-	for(int i=0; i<M; ++i)
-	{
-		for(int j=0; j<Q; ++j)
-		{
-			res[i][j] = dot(transpose(m1.getRow(i)), m2.getCol(j));
-		}
-	}
-
-	return res;
+*
+* \param[in] m1,m2 Matrix inputs
+*
+* Requires the two matrices to be compatible with multiplication.
+*/
+template <int M, int N, int P, int Q, class T>
+Matrix<M, Q, T> multiply(const Matrix<M, N, T>& m1, const Matrix<P, Q, T>& m2) {
+    if (N != P) {
+        throw std::runtime_error(
+            "Matrices don't have the right dimensions for multiplication");
+    }
+
+    Matrix<M, Q, T> res;
+
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < Q; ++j) {
+            res[i][j] = dot(transpose(m1.getRow(i)), m2.getCol(j));
+        }
+    }
+
+    return res;
 }
 
-} // matrix
+}  // matrix
 
-} // yage
+}  // yage
 
 #endif
diff --git a/include/YAGE/Physics/body.hpp b/include/YAGE/Physics/body.hpp
index b0869779..f32b767d 100644
--- a/include/YAGE/Physics/body.hpp
+++ b/include/YAGE/Physics/body.hpp
@@ -11,48 +11,46 @@
 
 #include "Math/matrix.hpp"
 
-namespace yage
-{
+namespace yage {
 
-class Body
-{
+class Body {
 public:
-	// gravity constant
-	static const double GRAVITY;	
+    // gravity constant
+    static const double GRAVITY;
+
 protected:
-	// center of mass of the object
-	Vector2d position_=Vector2d(0, 0);
-
-	// mass of the object
-    double mass_=1;
-	
-	// current velocity of the object
-	Vector2d velocity_=Vector2d(0, 0);
-
-	// boolean that defines if gravity can act on the object
-	bool gravity_=true;
-	
-	// current acceleration
-	Vector2d acceleration_=Vector2d(0, 0);
-
-	// force acting on the body
-	Vector2d force_=Vector2d(0, 0);
-	
+    // center of mass of the object
+    Vector2d position_ = Vector2d(0, 0);
+
+    // mass of the object
+    double mass_ = 1;
+
+    // current velocity of the object
+    Vector2d velocity_ = Vector2d(0, 0);
+
+    // boolean that defines if gravity can act on the object
+    bool gravity_ = true;
+
+    // current acceleration
+    Vector2d acceleration_ = Vector2d(0, 0);
+
+    // force acting on the body
+    Vector2d force_ = Vector2d(0, 0);
+
 public:
-	// apply force to the object and update the velocity
-	virtual void applyForce(const Vector2d &force)=0;
-	virtual void update()=0;
+    // apply force to the object and update the velocity
+    virtual void applyForce(const Vector2d& force) = 0;
+    virtual void update() = 0;
+
+    double xPosition() const;
+    double yPosition() const;
 
-	double xPosition() const;
-	double yPosition() const;
 protected:
-	// protected constructor to initialize member variables
-	Body(const Vector2d &position=Vector2d(0, 0),
-	     double mass=1,
-	     const Vector2d &velocity=Vector2d(0, 0),
-	     bool gravity=false);
+    // protected constructor to initialize member variables
+    Body(const Vector2d& position = Vector2d(0, 0), double mass = 1,
+         const Vector2d& velocity = Vector2d(0, 0), bool gravity = false);
 };
 
-} // namespace yage
+}  // namespace yage
 
 #endif
diff --git a/include/YAGE/Physics/collider.hpp b/include/YAGE/Physics/collider.hpp
index 716b7d4c..92b90de2 100644
--- a/include/YAGE/Physics/collider.hpp
+++ b/include/YAGE/Physics/collider.hpp
@@ -11,30 +11,29 @@
 
 #include <glm/glm.hpp>
 
-namespace yage
-{
+namespace yage {
 
 // The Collider class helps collision detection by providing a general shape
 // for different shapes to have their own collision algorithms.
-class Collider
-{
+class Collider {
 protected:
-	// position of the object
-	glm::vec2 position_;
+    // position of the object
+    glm::vec2 position_;
+
+    // size of the object
+    glm::vec2 size_;
 
-	// size of the object
-	glm::vec2 size_;
-	
 public:
-	Collider(const glm::vec2 &position, const glm::vec2 &size) : position_(position), size_(size) {}
+    Collider(const glm::vec2& position, const glm::vec2& size)
+        : position_(position), size_(size) {}
 
-	// function that checks if two colliders are colliding
-	virtual bool collides(const Collider &collider) const=0;
+    // function that checks if two colliders are colliding
+    virtual bool collides(const Collider& collider) const = 0;
 
-	// function that returns if a point is inside the shape
-	virtual bool inside(const glm::vec2 &point) const=0;
+    // function that returns if a point is inside the shape
+    virtual bool inside(const glm::vec2& point) const = 0;
 };
 
-} // namespace yage
+}  // namespace yage
 
 #endif
diff --git a/include/YAGE/Physics/collisionbody.hpp b/include/YAGE/Physics/collisionbody.hpp
index b7403e81..5ddacacd 100644
--- a/include/YAGE/Physics/collisionbody.hpp
+++ b/include/YAGE/Physics/collisionbody.hpp
@@ -11,18 +11,16 @@
 
 #include "Physics/body.hpp"
 
-namespace yage
-{
+namespace yage {
 
 // a collision body will be a body that is static and not affected by gravity,
 // with infinite mass
-class CollisionBody : public Body
-{
+class CollisionBody : public Body {
 public:
     CollisionBody();
     virtual ~CollisionBody();
 };
 
-} // yage
+}  // yage
 
 #endif
diff --git a/include/YAGE/Physics/particlebody.hpp b/include/YAGE/Physics/particlebody.hpp
index e107cb6a..ff8b3b85 100644
--- a/include/YAGE/Physics/particlebody.hpp
+++ b/include/YAGE/Physics/particlebody.hpp
@@ -13,22 +13,19 @@
 
 #include "body.hpp"
 
-namespace yage
-{
+namespace yage {
 
-class ParticleBody : public Body
-{
+class ParticleBody : public Body {
 public:
-	ParticleBody(const Vector2d &position=Vector2d(0, 0),
-	             double mass=1,
-	             const Vector2d &velocity=Vector2d(0, 0),
-	             bool gravity=true);
-
-	// apply a force to the rigid body
-	virtual void applyForce(const Vector2d &force);
-	virtual void update();
+    ParticleBody(const Vector2d& position = Vector2d(0, 0), double mass = 1,
+                 const Vector2d& velocity = Vector2d(0, 0),
+                 bool gravity = true);
+
+    // apply a force to the rigid body
+    virtual void applyForce(const Vector2d& force);
+    virtual void update();
 };
 
-} // yage
+}  // yage
 
 #endif
diff --git a/include/YAGE/Physics/rectanglecollider.hpp b/include/YAGE/Physics/rectanglecollider.hpp
index 62f11100..7f9dd7f7 100644
--- a/include/YAGE/Physics/rectanglecollider.hpp
+++ b/include/YAGE/Physics/rectanglecollider.hpp
@@ -13,18 +13,16 @@
 
 #include <glm/glm.hpp>
 
-namespace yage
-{
+namespace yage {
 
-class RectangleCollider : public Collider
-{
+class RectangleCollider : public Collider {
 public:
-	RectangleCollider(const glm::vec2 &position, const glm::vec2 &size);
+    RectangleCollider(const glm::vec2& position, const glm::vec2& size);
 
-	virtual bool collides(const Collider &collider) const;
-	virtual bool inside(const glm::vec2 &point) const;
+    virtual bool collides(const Collider& collider) const;
+    virtual bool inside(const glm::vec2& point) const;
 };
 
-} // yage
+}  // yage
 
 #endif
diff --git a/include/YAGE/Physics/rigidbody.hpp b/include/YAGE/Physics/rigidbody.hpp
index c8a2e497..fd19dc7c 100644
--- a/include/YAGE/Physics/rigidbody.hpp
+++ b/include/YAGE/Physics/rigidbody.hpp
@@ -13,18 +13,14 @@
 
 #include "particlebody.hpp"
 
-namespace yage
-{
+namespace yage {
 
-class RigidBody : public ParticleBody
-{
+class RigidBody : public ParticleBody {
 public:
-	RigidBody(const Vector2d &position=Vector2d(0, 0),
-	          double mass=1,
- 	          const Vector2d &velocity=Vector2d(0, 0),
-	          bool gravity=true);
+    RigidBody(const Vector2d& position = Vector2d(0, 0), double mass = 1,
+              const Vector2d& velocity = Vector2d(0, 0), bool gravity = true);
 };
 
-} // yage
+}  // yage
 
 #endif
diff --git a/include/YAGE/camera2d.hpp b/include/YAGE/camera2d.hpp
index 4c44ccaf..077d0544 100644
--- a/include/YAGE/camera2d.hpp
+++ b/include/YAGE/camera2d.hpp
@@ -14,27 +14,25 @@
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 
-namespace yage
-{
+namespace yage {
 
-class Camera2D
-{
+class Camera2D {
 private:
-    bool matrix_needs_update_=true;
-    float scale_=1;
+    bool matrix_needs_update_ = true;
+    float scale_ = 1;
     glm::vec2 position_;
     glm::mat4 camera_matrix_;
     glm::mat4 ortho_matrix_;
 
 public:
-    Camera2D(int screen_width=1280, int screen_height=720);
+    Camera2D(int screen_width = 1280, int screen_height = 720);
 
     // update camera location
-    void update(GlslProgram &program);
+    void update(GlslProgram& program);
     // camera movement
-    void move(const glm::vec2 &direction);
+    void move(const glm::vec2& direction);
 };
 
-} // yage
+}  // yage
 
 #endif
diff --git a/include/YAGE/glslprogram.hpp b/include/YAGE/glslprogram.hpp
index 70f30b73..fd97c3a0 100644
--- a/include/YAGE/glslprogram.hpp
+++ b/include/YAGE/glslprogram.hpp
@@ -13,38 +13,38 @@
 
 #include <string>
 
-namespace yage
-{
+namespace yage {
 
-class GlslProgram
-{
+class GlslProgram {
 private:
     /// compiled shader program id
-    GLuint program_id_=0;
-    GLuint vertex_shader_id_=0;
-    GLuint fragment_shader_id_=0;
-    int attribute_index_=0;
+    GLuint program_id_ = 0;
+    GLuint vertex_shader_id_ = 0;
+    GLuint fragment_shader_id_ = 0;
+    int attribute_index_ = 0;
 
     /// compiles one shader
-    void compileShader(const GLuint &shader, const std::string &file_path);
+    void compileShader(const GLuint& shader, const std::string& file_path);
+
 public:
-	GlslProgram()=default;
-	GlslProgram(const GlslProgram&)=delete;
-	GlslProgram(GlslProgram&&)=delete;
+    GlslProgram() = default;
+    GlslProgram(const GlslProgram&) = delete;
+    GlslProgram(GlslProgram&&) = delete;
     ~GlslProgram();
 
-	GlslProgram& operator=(const GlslProgram&)=delete;
-	GlslProgram& operator=(GlslProgram&&)=delete;
+    GlslProgram& operator=(const GlslProgram&) = delete;
+    GlslProgram& operator=(GlslProgram&&) = delete;
 
     /// compiles vertex and fragment shader
-    void compileShaders(const std::string &vertex_shader_path, const std::string &fragment_shader_path);
+    void compileShaders(const std::string& vertex_shader_path,
+                        const std::string& fragment_shader_path);
     void linkShaders();
-    void addAttribute(const std::string &attribute_name);
-    GLint getUniformLocation(const std::string &uniform_name);
+    void addAttribute(const std::string& attribute_name);
+    GLint getUniformLocation(const std::string& uniform_name);
     void use();
     void unuse();
 };
 
-} // yage
+}  // yage
 
 #endif
diff --git a/include/YAGE/imageloader.hpp b/include/YAGE/imageloader.hpp
index 4c0b5a36..90425cab 100644
--- a/include/YAGE/imageloader.hpp
+++ b/include/YAGE/imageloader.hpp
@@ -13,15 +13,13 @@
 
 #include <string>
 
-namespace yage
-{
+namespace yage {
 
-class ImageLoader
-{
+class ImageLoader {
 public:
-    static Texture loadPng(const std::string &file_path);
+    static Texture loadPng(const std::string& file_path);
 };
-    
-} // yage
+
+}  // yage
 
 #endif
diff --git a/include/YAGE/iomanager.hpp b/include/YAGE/iomanager.hpp
index 4295c598..3b1f5278 100644
--- a/include/YAGE/iomanager.hpp
+++ b/include/YAGE/iomanager.hpp
@@ -12,15 +12,14 @@
 #include <string>
 #include <vector>
 
-namespace yage
-{
+namespace yage {
 
-class IoManager
-{
+class IoManager {
 public:
-	static bool readFileToBuffer(const std::string &file_path, std::vector<unsigned char> &buffer);
+    static bool readFileToBuffer(const std::string &file_path,
+                                 std::vector<unsigned char> &buffer);
 };
-    
+
 } // yage
 
 #endif
diff --git a/include/YAGE/resourcemanager.hpp b/include/YAGE/resourcemanager.hpp
index 10f6cbb8..3d824d61 100644
--- a/include/YAGE/resourcemanager.hpp
+++ b/include/YAGE/resourcemanager.hpp
@@ -14,17 +14,16 @@
 
 #include <string>
 
-namespace yage
-{
+namespace yage {
 
-class ResourceManager
-{
+class ResourceManager {
 private:
     static TextureCache texture_cache_;
+
 public:
-    static Texture getTexture(const std::string &texture_path);
+    static Texture getTexture(const std::string& texture_path);
 };
-    
-} // yage
+
+}  // yage
 
 #endif
diff --git a/include/YAGE/sprite.hpp b/include/YAGE/sprite.hpp
index cddc0e26..969d0a67 100644
--- a/include/YAGE/sprite.hpp
+++ b/include/YAGE/sprite.hpp
@@ -15,11 +15,9 @@
 
 #include <string>
 
-namespace yage
-{
+namespace yage {
 
-class Sprite
-{
+class Sprite {
 private:
     float x_;
     float y_;
@@ -27,19 +25,21 @@ private:
     float height_;
     GLuint vbo_id_ = 0;
     Texture texture_;
+
 public:
     Sprite();
-	Sprite(const Sprite&)=delete;
-	Sprite(Sprite&&)=delete;
+    Sprite(const Sprite&) = delete;
+    Sprite(Sprite&&) = delete;
     ~Sprite();
 
-	Sprite& operator=(const Sprite&)=delete;
-	Sprite& operator=(Sprite&&)=delete;
+    Sprite& operator=(const Sprite&) = delete;
+    Sprite& operator=(Sprite&&) = delete;
 
-    void init(float x, float y, float width, float height, const std::string &texture_path);
+    void init(float x, float y, float width, float height,
+              const std::string& texture_path);
     void draw();
 };
-    
-} // yage
+
+}  // yage
 
 #endif
diff --git a/include/YAGE/spritebatch.hpp b/include/YAGE/spritebatch.hpp
index a3007bbf..9446c40f 100644
--- a/include/YAGE/spritebatch.hpp
+++ b/include/YAGE/spritebatch.hpp
@@ -16,13 +16,11 @@
 
 #include <vector>
 
-namespace yage
-{
+namespace yage {
 
 class SpriteBatch;
 
-class Glyph
-{
+class Glyph {
     // member variables
 private:
     GLuint texture_;
@@ -34,7 +32,9 @@ private:
 
     // member functions
 public:
-    Glyph(GLuint texture, float depth, const Vertex &top_left, const Vertex &top_right, const Vertex &bottom_right, const Vertex &bottom_left);
+    Glyph(GLuint texture, float depth, const Vertex& top_left,
+          const Vertex& top_right, const Vertex& bottom_right,
+          const Vertex& bottom_left);
 
     GLuint texture() const { return texture_; }
     float depth() const { return depth_; }
@@ -44,12 +44,11 @@ public:
     Vertex bottom_left() const { return bottom_left_; }
 };
 
-class RenderBatch
-{
+class RenderBatch {
     friend SpriteBatch;
     // member variables
 private:
-    GLsizei num_vertices_;    
+    GLsizei num_vertices_;
     GLint offset_;
     GLuint texture_;
 
@@ -63,42 +62,44 @@ public:
     GLuint texture() const { return texture_; }
 };
 
-class SpriteBatch
-{
+class SpriteBatch {
     // member variables
 public:
-    static const int NUM_VERTICES=6;
+    static const int NUM_VERTICES = 6;
+
 private:
-    GLuint vbo_=0;
-    GLuint vao_=0;
+    GLuint vbo_ = 0;
+    GLuint vao_ = 0;
     std::vector<Glyph> glyphs_;
-    std::vector<Glyph *> glyph_ptrs_;
+    std::vector<Glyph*> glyph_ptrs_;
     std::vector<RenderBatch> render_batches_;
 
     // member functions
 public:
     SpriteBatch();
-	SpriteBatch(const SpriteBatch&)=delete;
-	SpriteBatch(SpriteBatch&&)=delete;
+    SpriteBatch(const SpriteBatch&) = delete;
+    SpriteBatch(SpriteBatch&&) = delete;
     ~SpriteBatch();
 
-	SpriteBatch& operator=(const SpriteBatch&)=delete;
-	SpriteBatch& operator=(SpriteBatch&&)=delete;
+    SpriteBatch& operator=(const SpriteBatch&) = delete;
+    SpriteBatch& operator=(SpriteBatch&&) = delete;
 
     // initialize vaos and vbos
     void init();
     void begin();
     void end();
     // adds a sprite to the sprite batch to be rendered later
-    void draw(const glm::vec4 &destination_rect, const glm::vec4 &uv_rect, GLuint texture, const Color &color, float depth);
+    void draw(const glm::vec4& destination_rect, const glm::vec4& uv_rect,
+              GLuint texture, const Color& color, float depth);
     // render the batch
     void render();
+
 private:
     void createVertexArray();
     void createRenderBatches();
     void sortGlyphs();
 };
-    
-} // yage
+
+}  // yage
 
 #endif
diff --git a/include/YAGE/texture.hpp b/include/YAGE/texture.hpp
index 34accaca..65f3f651 100644
--- a/include/YAGE/texture.hpp
+++ b/include/YAGE/texture.hpp
@@ -11,16 +11,14 @@
 
 #include <GL/glew.h>
 
-namespace yage
-{
+namespace yage {
 
-struct Texture
-{
+struct Texture {
     GLuint id;
     int width;
     int height;
 };
-    
-} // yage
+
+}  // yage
 
 #endif
diff --git a/include/YAGE/texturecache.hpp b/include/YAGE/texturecache.hpp
index ac318230..0de5c12a 100644
--- a/include/YAGE/texturecache.hpp
+++ b/include/YAGE/texturecache.hpp
@@ -13,19 +13,18 @@
 
 #include <unordered_map>
 
-namespace yage
-{
+namespace yage {
 
-class TextureCache
-{
+class TextureCache {
 private:
     std::unordered_map<std::string, Texture> texture_map_;
+
 public:
     TextureCache();
 
-    Texture getTexture(const std::string &texture_path);
+    Texture getTexture(const std::string& texture_path);
 };
-    
-} // yage
+
+}  // yage
 
 #endif
diff --git a/include/YAGE/vertex.hpp b/include/YAGE/vertex.hpp
index a3848490..d3355b11 100644
--- a/include/YAGE/vertex.hpp
+++ b/include/YAGE/vertex.hpp
@@ -11,84 +11,66 @@
 
 #include <GL/glew.h>
 
-namespace yage
-{
+namespace yage {
 
-struct Position
-{
+struct Position {
     float x;
     float y;
 
-    Position()
-    {}
-    
-    Position(float x_, float y_) :
-	x(x_), y(y_)
-    {}
+    Position() {}
+
+    Position(float x_, float y_) : x(x_), y(y_) {}
 };
 
-struct Color
-{
+struct Color {
     GLubyte r;
     GLubyte g;
     GLubyte b;
     GLubyte a;
 
-    Color()
-    {}
+    Color() {}
 
-    Color(GLubyte r_, GLubyte g_, GLubyte b_, GLubyte a_) :
-	r(r_), g(g_), b(b_), a(a_)
-    {}
+    Color(GLubyte r_, GLubyte g_, GLubyte b_, GLubyte a_)
+        : r(r_), g(g_), b(b_), a(a_) {}
 };
 
-struct UV
-{
+struct UV {
     float u;
     float v;
 
-    UV()
-    {}
+    UV() {}
 
-    UV(float u_, float v_) :
-	u(u_), v(v_)
-    {}
+    UV(float u_, float v_) : u(u_), v(v_) {}
 };
 
-struct Vertex
-{
+struct Vertex {
     Position position;
     Color color;
     UV uv;
 
-    Vertex()
-    {}
+    Vertex() {}
 
-    Vertex(const Position &position_, const Color &color_, const UV &uv_) :
-	position(position_), color(color_), uv(uv_)
-    {}
+    Vertex(const Position& position_, const Color& color_, const UV& uv_)
+        : position(position_), color(color_), uv(uv_) {}
 
-    void setPosition(float x, float y)
-    {
-	position.x = x;
-	position.y = y;
+    void setPosition(float x, float y) {
+        position.x = x;
+        position.y = y;
     }
-    
-    void setColor(GLubyte r, GLubyte g, GLubyte b, GLubyte a)
-    {
-	color.r = r;
-	color.g = g;
-	color.b = b;
-	color.a = a;
+
+    void setColor(GLubyte r, GLubyte g, GLubyte b, GLubyte a) {
+        color.r = r;
+        color.g = g;
+        color.b = b;
+        color.a = a;
     }
-    
-    void setUv(float u, float v)
-    {
-	uv.u = u;
-	uv.v = v;
+
+    void setUv(float u, float v) {
+        uv.u = u;
+        uv.v = v;
     }
 };
-    
-} // yage
+
+}  // yage
 
 #endif
diff --git a/include/YAGE/window.hpp b/include/YAGE/window.hpp
index beefae3d..c2003a94 100644
--- a/include/YAGE/window.hpp
+++ b/include/YAGE/window.hpp
@@ -13,43 +13,41 @@
 
 #include <string>
 
-namespace yage
-{
+namespace yage {
 
 // window flags that can change it's appearance
-enum WindowFlags : unsigned
-{
-    SHOWN=0x1,
-    HIDDEN=0x2,
-    FULLSCREEN=0x4,
-    BORDERLESS=0x8,
+enum WindowFlags : unsigned {
+    SHOWN = 0x1,
+    HIDDEN = 0x2,
+    FULLSCREEN = 0x4,
+    BORDERLESS = 0x8,
 };
 
 // window wrapper around SDL_Window pointer
-class Window
-{
+class Window {
 private:
     /// window handle
-    SDL_Window *window_=nullptr;
-    
+    SDL_Window* window_ = nullptr;
+
 public:
     Window();
-	Window(const Window&)=delete;
-	Window(Window&&)=delete;
+    Window(const Window&) = delete;
+    Window(Window&&) = delete;
     /// destroys the window handle
-	~Window();
+    ~Window();
 
-	Window& operator=(const Window&)=delete;
-	Window& operator=(Window&&)=delete;
+    Window& operator=(const Window&) = delete;
+    Window& operator=(Window&&) = delete;
 
     /// create the window, initialize the handle and update the width and height
-    void create(const std::string &window_name, int width, int height, unsigned flags=WindowFlags::SHOWN);
+    void create(const std::string& window_name, int width, int height,
+                unsigned flags = WindowFlags::SHOWN);
     /// swap the buffer
     void swapBuffer();
     /// clear buffer
     void clearBuffer();
 };
-    
-} // namespace yage
+
+}  // namespace yage
 
 #endif
diff --git a/include/YAGE/yage.hpp b/include/YAGE/yage.hpp
index 1045e12b..45c1c4d7 100644
--- a/include/YAGE/yage.hpp
+++ b/include/YAGE/yage.hpp
@@ -25,23 +25,16 @@
 
 #include <stdexcept>
 
-namespace yage
-{
-
-bool init()
-{
-	if(SDL_Init(SDL_INIT_VIDEO))
-	{
-		return false;
-	}
-	return true;
-}
+namespace yage {
 
-void quit()
-{
-	SDL_Quit();
+bool init() {
+    if (SDL_Init(SDL_INIT_VIDEO)) {
+        return false;
+    }
+    return true;
 }
 
+void quit() { SDL_Quit(); }
 };
 
 #endif
diff --git a/src/body.cpp b/src/body.cpp
index ad92b0ca..a17f6ee3 100644
--- a/src/body.cpp
+++ b/src/body.cpp
@@ -8,23 +8,19 @@
 
 #include "Physics/body.hpp"
 
-namespace yage
-{
+namespace yage {
 
-const double Body::GRAVITY=-9.81;
+const double Body::GRAVITY = -9.81;
 
-double Body::xPosition() const
-{
-	return position_[0];
-}
+double Body::xPosition() const { return position_[0]; }
 
-double Body::yPosition() const
-{
-	return position_[1];
-}
+double Body::yPosition() const { return position_[1]; }
 
-Body::Body(const Vector2d &position, double mass, const Vector2d &velocity, bool gravity) :
-	position_(position), mass_(mass), velocity_(velocity), gravity_(gravity)
-{}
+Body::Body(const Vector2d& position, double mass, const Vector2d& velocity,
+           bool gravity)
+    : position_(position),
+      mass_(mass),
+      velocity_(velocity),
+      gravity_(gravity) {}
 
-} // yage
+}  // yage
diff --git a/src/camera2d.cpp b/src/camera2d.cpp
index 88b468de..690ac98d 100644
--- a/src/camera2d.cpp
+++ b/src/camera2d.cpp
@@ -10,36 +10,32 @@
 
 #include <GL/glew.h>
 
-namespace yage
-{
-
-Camera2D::Camera2D(int screen_width, int screen_height) :
-	position_(0.f, 0.f),
-	camera_matrix_(1.f),
-	ortho_matrix_(glm::ortho(0.f, (float)screen_width, 0.f, (float)screen_height))
-{}
-
-void Camera2D::update(GlslProgram &program)
-{
-	if(matrix_needs_update_)
-	{
-		glm::vec3 translate(-position_.x, -position_.y, 0.f);
-		glm::vec3 scale(scale_, scale_, 0.f);
-	    
-		camera_matrix_=glm::translate(ortho_matrix_, translate);
-		camera_matrix_=glm::scale(glm::mat4(1.f), scale)*camera_matrix_;
-
-		matrix_needs_update_=false;
-	}
-
-	GLint matrix_location = program.getUniformLocation("P");
-	glUniformMatrix4fv(matrix_location, 1, GL_FALSE, &(camera_matrix_[0][0]));    
+namespace yage {
+
+Camera2D::Camera2D(int screen_width, int screen_height)
+    : position_(0.f, 0.f),
+      camera_matrix_(1.f),
+      ortho_matrix_(
+          glm::ortho(0.f, (float)screen_width, 0.f, (float)screen_height)) {}
+
+void Camera2D::update(GlslProgram& program) {
+    if (matrix_needs_update_) {
+        glm::vec3 translate(-position_.x, -position_.y, 0.f);
+        glm::vec3 scale(scale_, scale_, 0.f);
+
+        camera_matrix_ = glm::translate(ortho_matrix_, translate);
+        camera_matrix_ = glm::scale(glm::mat4(1.f), scale) * camera_matrix_;
+
+        matrix_needs_update_ = false;
+    }
+
+    GLint matrix_location = program.getUniformLocation("P");
+    glUniformMatrix4fv(matrix_location, 1, GL_FALSE, &(camera_matrix_[0][0]));
 }
 
-void Camera2D::move(const glm::vec2 &direction)
-{
-	position_+=direction;
-	matrix_needs_update_=true;
+void Camera2D::move(const glm::vec2& direction) {
+    position_ += direction;
+    matrix_needs_update_ = true;
 }
 
-} // yage
+}  // yage
diff --git a/src/glslprogram.cpp b/src/glslprogram.cpp
index 18fee54e..a5f95ad5 100644
--- a/src/glslprogram.cpp
+++ b/src/glslprogram.cpp
@@ -12,137 +12,126 @@
 #include <stdexcept>
 #include <vector>
 
-namespace yage
-{
-
-GlslProgram::~GlslProgram()
-{
-	// cleanup all the shaders and the program
-	if(fragment_shader_id_ != 0)
-		glDeleteShader(fragment_shader_id_);
-    
-	if(vertex_shader_id_ != 0)
-		glDeleteShader(vertex_shader_id_);
-    
-	if(program_id_ != 0)
-		glDeleteProgram(program_id_);
+namespace yage {
+
+GlslProgram::~GlslProgram() {
+    // cleanup all the shaders and the program
+    if (fragment_shader_id_ != 0) glDeleteShader(fragment_shader_id_);
+
+    if (vertex_shader_id_ != 0) glDeleteShader(vertex_shader_id_);
+
+    if (program_id_ != 0) glDeleteProgram(program_id_);
 }
 
-void GlslProgram::compileShader(const GLuint &shader, const std::string &file_path)
-{
-	// get a string with the input from the shader file
-	std::ifstream file(file_path);
-	if(!file.is_open())
-		throw std::runtime_error("Failed to open '"+file_path+"'");
-
-	std::string content = "";
-	std::string line;
-
-	while(std::getline(file, line))
-		content+=line+"\n";
-	file.close();
-
-	// cast source to a c string to get the address of it and input it for compilation
-	const GLchar *vertex_source = (const GLchar *)content.c_str();
-	glShaderSource(shader, 1, &vertex_source, nullptr);
-	glCompileShader(shader);
-
-	// check if compilation was successful
-	GLint is_compiled = 0;
-	glGetShaderiv(shader, GL_COMPILE_STATUS, (int *)&is_compiled);
-
-	// if it isn't compiled throw exception to clean up
-	if(is_compiled == GL_FALSE)
-	{
-		GLint max_length = 0;
-		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &max_length);
- 
-		std::vector<GLchar> error_log(max_length);
-		glGetShaderInfoLog(shader, max_length, &max_length, &error_log[0]);
-		std::string error_log_str((const char *)&error_log[0]);
-	
-		throw std::runtime_error("Couldn't compile "+file_path+" : "+error_log_str);
-	}
+void GlslProgram::compileShader(const GLuint& shader,
+                                const std::string& file_path) {
+    // get a string with the input from the shader file
+    std::ifstream file(file_path);
+    if (!file.is_open())
+        throw std::runtime_error("Failed to open '" + file_path + "'");
+
+    std::string content = "";
+    std::string line;
+
+    while (std::getline(file, line)) content += line + "\n";
+    file.close();
+
+    // cast source to a c string to get the address of it and input it for
+    // compilation
+    const GLchar* vertex_source = (const GLchar*)content.c_str();
+    glShaderSource(shader, 1, &vertex_source, nullptr);
+    glCompileShader(shader);
+
+    // check if compilation was successful
+    GLint is_compiled = 0;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, (int*)&is_compiled);
+
+    // if it isn't compiled throw exception to clean up
+    if (is_compiled == GL_FALSE) {
+        GLint max_length = 0;
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &max_length);
+
+        std::vector<GLchar> error_log(max_length);
+        glGetShaderInfoLog(shader, max_length, &max_length, &error_log[0]);
+        std::string error_log_str((const char*)&error_log[0]);
+
+        throw std::runtime_error("Couldn't compile " + file_path + " : " +
+                                 error_log_str);
+    }
 }
 
-void GlslProgram::compileShaders(const std::string &vertex_shader_path, const std::string &fragment_shader_path)
-{
-	// create the program that will be run on GPU
-	program_id_ = glCreateProgram();
+void GlslProgram::compileShaders(const std::string& vertex_shader_path,
+                                 const std::string& fragment_shader_path) {
+    // create the program that will be run on GPU
+    program_id_ = glCreateProgram();
 
-	// create vertex shader
-	vertex_shader_id_ = glCreateShader(GL_VERTEX_SHADER);
-	if(vertex_shader_id_ == 0)
-		throw std::runtime_error("Vertex shader failed to be created");
+    // create vertex shader
+    vertex_shader_id_ = glCreateShader(GL_VERTEX_SHADER);
+    if (vertex_shader_id_ == 0)
+        throw std::runtime_error("Vertex shader failed to be created");
 
-	// create fragment shader
-	fragment_shader_id_ = glCreateShader(GL_FRAGMENT_SHADER);
-	if(fragment_shader_id_ == 0)
-		throw std::runtime_error("Fragment shader failed to be created");
+    // create fragment shader
+    fragment_shader_id_ = glCreateShader(GL_FRAGMENT_SHADER);
+    if (fragment_shader_id_ == 0)
+        throw std::runtime_error("Fragment shader failed to be created");
 
-	// compile the two shaders
-	compileShader(vertex_shader_id_, vertex_shader_path);
-	compileShader(fragment_shader_id_, fragment_shader_path);    
+    // compile the two shaders
+    compileShader(vertex_shader_id_, vertex_shader_path);
+    compileShader(fragment_shader_id_, fragment_shader_path);
 }
 
-void GlslProgram::linkShaders()
-{
-	// attach the shaders that we want
-	glAttachShader(program_id_, vertex_shader_id_);
-	glAttachShader(program_id_, fragment_shader_id_);
+void GlslProgram::linkShaders() {
+    // attach the shaders that we want
+    glAttachShader(program_id_, vertex_shader_id_);
+    glAttachShader(program_id_, fragment_shader_id_);
 
-	// link our program
-	glLinkProgram(program_id_);
+    // link our program
+    glLinkProgram(program_id_);
 
-	GLint is_linked = 0;
-	glGetProgramiv(program_id_, GL_LINK_STATUS, (int *)&is_linked);
-	if(is_linked == GL_FALSE)
-	{
-		GLint max_length = 0;
-		glGetProgramiv(program_id_, GL_INFO_LOG_LENGTH, &max_length);
+    GLint is_linked = 0;
+    glGetProgramiv(program_id_, GL_LINK_STATUS, (int*)&is_linked);
+    if (is_linked == GL_FALSE) {
+        GLint max_length = 0;
+        glGetProgramiv(program_id_, GL_INFO_LOG_LENGTH, &max_length);
 
-		std::vector<GLchar> error_log(max_length);
-		glGetProgramInfoLog(program_id_, max_length, &max_length, &error_log[0]);
+        std::vector<GLchar> error_log(max_length);
+        glGetProgramInfoLog(program_id_, max_length, &max_length,
+                            &error_log[0]);
 
-		std::string error_log_str((const char *)&error_log[0]);
+        std::string error_log_str((const char*)&error_log[0]);
 
-		throw std::runtime_error("Could not link program : "+error_log_str);
-	}
+        throw std::runtime_error("Could not link program : " + error_log_str);
+    }
 
-	// detach shaders after successful link
-	glDetachShader(program_id_, fragment_shader_id_);
-	glDetachShader(program_id_, vertex_shader_id_);
+    // detach shaders after successful link
+    glDetachShader(program_id_, fragment_shader_id_);
+    glDetachShader(program_id_, vertex_shader_id_);
 
-	// we can then delete the shaders once we have the program
-	glDeleteShader(fragment_shader_id_);
-	glDeleteShader(vertex_shader_id_);    
+    // we can then delete the shaders once we have the program
+    glDeleteShader(fragment_shader_id_);
+    glDeleteShader(vertex_shader_id_);
 }
 
-void GlslProgram::addAttribute(const std::string &attribute_name)
-{
-	glBindAttribLocation(program_id_, attribute_index_++, attribute_name.c_str());
+void GlslProgram::addAttribute(const std::string& attribute_name) {
+    glBindAttribLocation(program_id_, attribute_index_++,
+                         attribute_name.c_str());
 }
 
-GLint GlslProgram::getUniformLocation(const std::string &uniform_name)
-{
-	GLint location = glGetUniformLocation(program_id_, uniform_name.c_str());
-	if((GLuint)location == GL_INVALID_INDEX)
-		throw std::runtime_error("'"+uniform_name+"' not found");
-	return location;
+GLint GlslProgram::getUniformLocation(const std::string& uniform_name) {
+    GLint location = glGetUniformLocation(program_id_, uniform_name.c_str());
+    if ((GLuint)location == GL_INVALID_INDEX)
+        throw std::runtime_error("'" + uniform_name + "' not found");
+    return location;
 }
 
-void GlslProgram::use()
-{
-	glUseProgram(program_id_);
-	for(int i = 0; i < attribute_index_; ++i)
-		glEnableVertexAttribArray(i);
+void GlslProgram::use() {
+    glUseProgram(program_id_);
+    for (int i = 0; i < attribute_index_; ++i) glEnableVertexAttribArray(i);
 }
 
-void GlslProgram::unuse()
-{
-	for(int i = 0; i < attribute_index_; ++i)
-		glDisableVertexAttribArray(i);
-	glUseProgram(0);
+void GlslProgram::unuse() {
+    for (int i = 0; i < attribute_index_; ++i) glDisableVertexAttribArray(i);
+    glUseProgram(0);
 }
-    
-} // yage
+
+}  // yage
diff --git a/src/inputmanager.cpp b/src/inputmanager.cpp
index c9c80d93..2583201a 100644
--- a/src/inputmanager.cpp
+++ b/src/inputmanager.cpp
@@ -8,25 +8,15 @@
 
 #include "inputmanager.hpp"
 
-namespace yage
-{
+namespace yage {
 
-void InputManager::keyPressed(unsigned key)
-{
-	key_map_[key]=true;
-}
+void InputManager::keyPressed(unsigned key) { key_map_[key] = true; }
 
-void InputManager::keyReleased(unsigned key)
-{
-	key_map_[key]=false;
-}
+void InputManager::keyReleased(unsigned key) { key_map_[key] = false; }
 
-bool InputManager::isKeyPressed(unsigned key) const
-{
-	auto key_index=key_map_.find(key);
-	if(key_index!=key_map_.end())
-		return key_index->second;
-	return false;
+bool InputManager::isKeyPressed(unsigned key) const {
+    auto key_index = key_map_.find(key);
+    if (key_index != key_map_.end()) return key_index->second;
+    return false;
 }
-
 }
diff --git a/src/iomanager.cpp b/src/iomanager.cpp
index bcb1dcd0..6059bfbc 100644
--- a/src/iomanager.cpp
+++ b/src/iomanager.cpp
@@ -11,30 +11,29 @@
 #include <fstream>
 #include <stdexcept>
 
-namespace yage
-{
-
-bool IoManager::readFileToBuffer(const std::string &file_path, std::vector<unsigned char> &buffer)
-{
-	std::ifstream file(file_path, std::ios::binary);
-	if(!file.is_open())
-		throw std::runtime_error("Could not open '"+file_path+"'");
-    
-	// seek to the end
-	file.seekg(0, std::ios::end);
-
-	// get the file size
-	int file_size = file.tellg();
-	file.seekg(0, std::ios::beg);
-
-	// reduce file size by header bytes
-	file_size -= file.tellg();
-
-	buffer.resize(file_size);
-	file.read((char *)&buffer[0], file_size);
-	file.close();
-
-	return true;
+namespace yage {
+
+bool IoManager::readFileToBuffer(const std::string& file_path,
+                                 std::vector<unsigned char>& buffer) {
+    std::ifstream file(file_path, std::ios::binary);
+    if (!file.is_open())
+        throw std::runtime_error("Could not open '" + file_path + "'");
+
+    // seek to the end
+    file.seekg(0, std::ios::end);
+
+    // get the file size
+    int file_size = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    // reduce file size by header bytes
+    file_size -= file.tellg();
+
+    buffer.resize(file_size);
+    file.read((char*)&buffer[0], file_size);
+    file.close();
+
+    return true;
 }
-    
-} // yage
+
+}  // yage
diff --git a/src/particlebody.cpp b/src/particlebody.cpp
index a66489e9..09e0a1c0 100644
--- a/src/particlebody.cpp
+++ b/src/particlebody.cpp
@@ -8,47 +8,41 @@
 
 #include "Physics/particlebody.hpp"
 
-#include <iostream>
 #include <cmath>
+#include <iostream>
 
-namespace yage
-{
+namespace yage {
 
-ParticleBody::ParticleBody(const Vector2d &position,
-                           double mass,
-                           const Vector2d &velocity,
-                           bool gravity) :
-	Body(position, mass, velocity, gravity)
-{}
+ParticleBody::ParticleBody(const Vector2d& position, double mass,
+                           const Vector2d& velocity, bool gravity)
+    : Body(position, mass, velocity, gravity) {}
 
-void ParticleBody::applyForce(const Vector2d &force)
-{
-	force_+=force;
-}
+void ParticleBody::applyForce(const Vector2d& force) { force_ += force; }
 
-void ParticleBody::update()
-{
-	// set the time_step for 60fps
-	double time_step=1.0/60.0;
+void ParticleBody::update() {
+    // set the time_step for 60fps
+    double time_step = 1.0 / 60.0;
 
-	// set the last acceleration
-	Vector2d last_acceleration=acceleration_;
+    // set the last acceleration
+    Vector2d last_acceleration = acceleration_;
 
-	// update the position of the body
-	position_+=velocity_*time_step+(0.5*last_acceleration*std::pow(time_step, 2));
+    // update the position of the body
+    position_ += velocity_ * time_step +
+                 (0.5 * last_acceleration * std::pow(time_step, 2));
 
-	// update the acceleration
-	if(gravity_)
-		acceleration_=Vector2d(force_.x()/mass_, (GRAVITY+force_.y())/mass_);
-	else
-		acceleration_=Vector2d(force_.x()/mass_, force_.y()/mass_);
+    // update the acceleration
+    if (gravity_)
+        acceleration_ =
+            Vector2d(force_.x() / mass_, (GRAVITY + force_.y()) / mass_);
+    else
+        acceleration_ = Vector2d(force_.x() / mass_, force_.y() / mass_);
 
-	std::cout<<acceleration_<<"\n";
+    std::cout << acceleration_ << "\n";
 
-	Vector2d avg_acceleration=(acceleration_+last_acceleration)/2.0;
+    Vector2d avg_acceleration = (acceleration_ + last_acceleration) / 2.0;
 
-	// update the velocity of the body
-	velocity_+=avg_acceleration*time_step;
+    // update the velocity of the body
+    velocity_ += avg_acceleration * time_step;
 }
 
-} // yage
+}  // yage
diff --git a/src/picopng.cpp b/src/picopng.cpp
index b2dd70fe..6fe9c1f7 100644
--- a/src/picopng.cpp
+++ b/src/picopng.cpp
@@ -1,539 +1,999 @@
-#include <vector>
 #include <cstdlib>
+#include <vector>
 
-namespace yage
-{
+namespace yage {
 
 /*
-  decodePNG: The picoPNG function, decodes a PNG file buffer in memory, into a raw pixel buffer.
+  decodePNG: The picoPNG function, decodes a PNG file buffer in memory, into a
+  raw pixel buffer.
   out_image: output parameter, this will contain the raw pixels after decoding.
   By default the output is 32-bit RGBA color.
   The std::vector is automatically resized to the correct size.
-  image_width: output_parameter, this will contain the width of the image in pixels.
-  image_height: output_parameter, this will contain the height of the image in pixels.
-  in_png: pointer to the buffer of the PNG file in memory. To get it from a file on
+  image_width: output_parameter, this will contain the width of the image in
+  pixels.
+  image_height: output_parameter, this will contain the height of the image in
+  pixels.
+  in_png: pointer to the buffer of the PNG file in memory. To get it from a file
+  on
   disk, load it and store it in a memory buffer yourself first.
   in_size: size of the input PNG file in bytes.
   convert_to_rgba32: optional parameter, true by default.
   Set to true to get the output in RGBA 32-bit (8 bit per channel) color format
   no matter what color type the original PNG image had. This gives predictable,
   useable data from any random input PNG.
-  Set to false to do no color conversion at all. The result then has the same data
+  Set to false to do no color conversion at all. The result then has the same
+  data
   type as the PNG image, which can range from 1 bit to 64 bits per pixel.
   Information about the color type or palette colors are not provided. You need
   to know this information yourself to be able to use the data so this only
-  works for trusted PNG files. Use LodePNG instead of picoPNG if you need this information.
+  works for trusted PNG files. Use LodePNG instead of picoPNG if you need this
+  information.
   return: 0 if success, not 0 if some error occured.
 */
-int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width, unsigned long& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32)
-{
-	// picoPNG version 20101224
-	// Copyright (c) 2005-2010 Lode Vandevenne
-	//
-	// 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.
-  
-	// picoPNG is a PNG decoder in one C++ function of around 500 lines. Use picoPNG for
-	// programs that need only 1 .cpp file. Since it's a single function, it's very limited,
-	// it can convert a PNG to raw pixel data either converted to 32-bit RGBA color or
-	// with no color conversion at all. For anything more complex, another tiny library
-	// is available: LodePNG (lodepng.c(pp)), which is a single source and header file.
-	// Apologies for the compact code style, it's to make this tiny.
-  
-	static const unsigned long LENBASE[29] =  {3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258};
-	static const unsigned long LENEXTRA[29] = {0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0};
-	static const unsigned long DISTBASE[30] =  {1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577};
-	static const unsigned long DISTEXTRA[30] = {0,0,0,0,1,1,2, 2, 3, 3, 4, 4, 5, 5,  6,  6,  7,  7,  8,  8,   9,   9,  10,  10,  11,  11,  12,   12,   13,   13};
-	static const unsigned long CLCL[19] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; //code length code lengths
-	struct Zlib //nested functions for zlib decompression
-	{
-		static unsigned long readBitFromStream(size_t& bitp, const unsigned char* bits) { unsigned long result = (bits[bitp >> 3] >> (bitp & 0x7)) & 1; bitp++; return result;}
-		static unsigned long readBitsFromStream(size_t& bitp, const unsigned char* bits, size_t nbits)
-		{
-			unsigned long result = 0;
-			for(size_t i = 0; i < nbits; i++) result += (readBitFromStream(bitp, bits)) << i;
-			return result;
-		}
-		struct HuffmanTree
-		{
-			int makeFromLengths(const std::vector<unsigned long>& bitlen, unsigned long maxbitlen)
-			{ //make tree given the lengths
-				unsigned long numcodes = (unsigned long)(bitlen.size()), treepos = 0, nodefilled = 0;
-				std::vector<unsigned long> tree1d(numcodes), blcount(maxbitlen + 1, 0), nextcode(maxbitlen + 1, 0);
-				for(unsigned long bits = 0; bits < numcodes; bits++) blcount[bitlen[bits]]++; //count number of instances of each code length
-				for(unsigned long bits = 1; bits <= maxbitlen; bits++) nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1]) << 1;
-				for(unsigned long n = 0; n < numcodes; n++) if(bitlen[n] != 0) tree1d[n] = nextcode[bitlen[n]]++; //generate all the codes
-				tree2d.clear(); tree2d.resize(numcodes * 2, 32767); //32767 here means the tree2d isn't filled there yet
-				for(unsigned long n = 0; n < numcodes; n++) //the codes
-					for(unsigned long i = 0; i < bitlen[n]; i++) //the bits for this code
-					{
-						unsigned long bit = (tree1d[n] >> (bitlen[n] - i - 1)) & 1;
-						if(treepos > numcodes - 2) return 55;
-						if(tree2d[2 * treepos + bit] == 32767) //not yet filled in
-						{
-							if(i + 1 == bitlen[n]) { tree2d[2 * treepos + bit] = n; treepos = 0; } //last bit
-							else { tree2d[2 * treepos + bit] = ++nodefilled + numcodes; treepos = nodefilled; } //addresses are encoded as values > numcodes
-						}
-						else treepos = tree2d[2 * treepos + bit] - numcodes; //subtract numcodes from address to get address value
-					}
-				return 0;
-			}
-			int decode(bool& decoded, unsigned long& result, size_t& treepos, unsigned long bit) const
-			{ //Decodes a symbol from the tree
-				unsigned long numcodes = (unsigned long)tree2d.size() / 2;
-				if(treepos >= numcodes) return 11; //error: you appeared outside the codetree
-				result = tree2d[2 * treepos + bit];
-				decoded = (result < numcodes);
-				treepos = decoded ? 0 : result - numcodes;
-				return 0;
-			}
-			std::vector<unsigned long> tree2d; //2D representation of a huffman tree: The one dimension is "0" or "1", the other contains all nodes and leaves of the tree.
-		};
-		struct Inflator
-		{
-			int error;
-			void inflate(std::vector<unsigned char>& out, const std::vector<unsigned char>& in, size_t inpos = 0)
-			{
-				size_t bp = 0, pos = 0; //bit pointer and byte pointer
-				error = 0;
-				unsigned long BFINAL = 0;
-				while(!BFINAL && !error)
-				{
-					if(bp >> 3 >= in.size()) { error = 52; return; } //error, bit pointer will jump past memory
-					BFINAL = readBitFromStream(bp, &in[inpos]);
-					unsigned long BTYPE = readBitFromStream(bp, &in[inpos]); BTYPE += 2 * readBitFromStream(bp, &in[inpos]);
-					if(BTYPE == 3) { error = 20; return; } //error: invalid BTYPE
-					else if(BTYPE == 0) inflateNoCompression(out, &in[inpos], bp, pos, in.size());
-					else inflateHuffmanBlock(out, &in[inpos], bp, pos, in.size(), BTYPE);
-				}
-				if(!error) out.resize(pos); //Only now we know the true size of out, resize it to that
-			}
-			void generateFixedTrees(HuffmanTree& tree, HuffmanTree& treeD) //get the tree of a deflated block with fixed tree
-			{
-				std::vector<unsigned long> bitlen(288, 8), bitlenD(32, 5);;
-				for(size_t i = 144; i <= 255; i++) bitlen[i] = 9;
-				for(size_t i = 256; i <= 279; i++) bitlen[i] = 7;
-				tree.makeFromLengths(bitlen, 15);
-				treeD.makeFromLengths(bitlenD, 15);
-			}
-			HuffmanTree codetree, codetreeD, codelengthcodetree; //the code tree for Huffman codes, dist codes, and code length codes
-			unsigned long huffmanDecodeSymbol(const unsigned char* in, size_t& bp, const HuffmanTree& codetree, size_t inlength)
-			{ //decode a single symbol from given list of bits with given code tree. return value is the symbol
-				bool decoded; unsigned long ct;
-				for(size_t treepos = 0;;)
-				{
-					if((bp & 0x07) == 0 && (bp >> 3) > inlength) { error = 10; return 0; } //error: end reached without endcode
-					error = codetree.decode(decoded, ct, treepos, readBitFromStream(bp, in)); if(error) return 0; //stop, an error happened
-					if(decoded) return ct;
-				}
-			}
-			void getTreeInflateDynamic(HuffmanTree& tree, HuffmanTree& treeD, const unsigned char* in, size_t& bp, size_t inlength)
-			{ //get the tree of a deflated block with dynamic tree, the tree itself is also Huffman compressed with a known tree
-				std::vector<unsigned long> bitlen(288, 0), bitlenD(32, 0);
-				if(bp >> 3 >= inlength - 2) { error = 49; return; } //the bit pointer is or will go past the memory
-				size_t HLIT =  readBitsFromStream(bp, in, 5) + 257; //number of literal/length codes + 257
-				size_t HDIST = readBitsFromStream(bp, in, 5) + 1; //number of dist codes + 1
-				size_t HCLEN = readBitsFromStream(bp, in, 4) + 4; //number of code length codes + 4
-				std::vector<unsigned long> codelengthcode(19); //lengths of tree to decode the lengths of the dynamic tree
-				for(size_t i = 0; i < 19; i++) codelengthcode[CLCL[i]] = (i < HCLEN) ? readBitsFromStream(bp, in, 3) : 0;
-				error = codelengthcodetree.makeFromLengths(codelengthcode, 7); if(error) return;
-				size_t i = 0, replength;
-				while(i < HLIT + HDIST)
-				{
-					unsigned long code = huffmanDecodeSymbol(in, bp, codelengthcodetree, inlength); if(error) return;
-					if(code <= 15)  { if(i < HLIT) bitlen[i++] = code; else bitlenD[i++ - HLIT] = code; } //a length code
-					else if(code == 16) //repeat previous
-					{
-						if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
-						replength = 3 + readBitsFromStream(bp, in, 2);
-						unsigned long value; //set value to the previous code
-						if((i - 1) < HLIT) value = bitlen[i - 1];
-						else value = bitlenD[i - HLIT - 1];
-						for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths
-						{
-							if(i >= HLIT + HDIST) { error = 13; return; } //error: i is larger than the amount of codes
-							if(i < HLIT) bitlen[i++] = value; else bitlenD[i++ - HLIT] = value;
-						}
-					}
-					else if(code == 17) //repeat "0" 3-10 times
-					{
-						if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
-						replength = 3 + readBitsFromStream(bp, in, 3);
-						for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths
-						{
-							if(i >= HLIT + HDIST) { error = 14; return; } //error: i is larger than the amount of codes
-							if(i < HLIT) bitlen[i++] = 0; else bitlenD[i++ - HLIT] = 0;
-						}
-					}
-					else if(code == 18) //repeat "0" 11-138 times
-					{
-						if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
-						replength = 11 + readBitsFromStream(bp, in, 7);
-						for(size_t n = 0; n < replength; n++) //repeat this value in the next lengths
-						{
-							if(i >= HLIT + HDIST) { error = 15; return; } //error: i is larger than the amount of codes
-							if(i < HLIT) bitlen[i++] = 0; else bitlenD[i++ - HLIT] = 0;
-						}
-					}
-					else { error = 16; return; } //error: somehow an unexisting code appeared. This can never happen.
-				}
-				if(bitlen[256] == 0) { error = 64; return; } //the length of the end code 256 must be larger than 0
-				error = tree.makeFromLengths(bitlen, 15); if(error) return; //now we've finally got HLIT and HDIST, so generate the code trees, and the function is done
-				error = treeD.makeFromLengths(bitlenD, 15); if(error) return;
-			}
-			void inflateHuffmanBlock(std::vector<unsigned char>& out, const unsigned char* in, size_t& bp, size_t& pos, size_t inlength, unsigned long btype) 
-			{
-				if(btype == 1) { generateFixedTrees(codetree, codetreeD); }
-				else if(btype == 2) { getTreeInflateDynamic(codetree, codetreeD, in, bp, inlength); if(error) return; }
-				for(;;)
-				{
-					unsigned long code = huffmanDecodeSymbol(in, bp, codetree, inlength); if(error) return;
-					if(code == 256) return; //end code
-					else if(code <= 255) //literal symbol
-					{
-						if(pos >= out.size()) out.resize((pos + 1) * 2); //reserve more room
-						out[pos++] = (unsigned char)(code);
-					}
-					else if(code >= 257 && code <= 285) //length code
-					{
-						size_t length = LENBASE[code - 257], numextrabits = LENEXTRA[code - 257];
-						if((bp >> 3) >= inlength) { error = 51; return; } //error, bit pointer will jump past memory
-						length += readBitsFromStream(bp, in, numextrabits);
-						unsigned long codeD = huffmanDecodeSymbol(in, bp, codetreeD, inlength); if(error) return;
-						if(codeD > 29) { error = 18; return; } //error: invalid dist code (30-31 are never used)
-						unsigned long dist = DISTBASE[codeD], numextrabitsD = DISTEXTRA[codeD];
-						if((bp >> 3) >= inlength) { error = 51; return; } //error, bit pointer will jump past memory
-						dist += readBitsFromStream(bp, in, numextrabitsD);
-						size_t start = pos, back = start - dist; //backwards
-						if(pos + length >= out.size()) out.resize((pos + length) * 2); //reserve more room
-						for(size_t i = 0; i < length; i++) { out[pos++] = out[back++]; if(back >= start) back = start - dist; }
-					}
-				}
-			}
-			void inflateNoCompression(std::vector<unsigned char>& out, const unsigned char* in, size_t& bp, size_t& pos, size_t inlength)
-			{
-				while((bp & 0x7) != 0) bp++; //go to first boundary of byte
-				size_t p = bp / 8;
-				if(p >= inlength - 4) { error = 52; return; } //error, bit pointer will jump past memory
-				unsigned long LEN = in[p] + 256 * in[p + 1], NLEN = in[p + 2] + 256 * in[p + 3]; p += 4;
-				if(LEN + NLEN != 65535) { error = 21; return; } //error: NLEN is not one's complement of LEN
-				if(pos + LEN >= out.size()) out.resize(pos + LEN);
-				if(p + LEN > inlength) { error = 23; return; } //error: reading outside of in buffer
-				for(unsigned long n = 0; n < LEN; n++) out[pos++] = in[p++]; //read LEN bytes of literal data
-				bp = p * 8;
-			}
-		};
-		int decompress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in) //returns error value
-		{
-			Inflator inflator;
-			if(in.size() < 2) { return 53; } //error, size of zlib data too small
-			if((in[0] * 256 + in[1]) % 31 != 0) { return 24; } //error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way
-			unsigned long CM = in[0] & 15, CINFO = (in[0] >> 4) & 15, FDICT = (in[1] >> 5) & 1;
-			if(CM != 8 || CINFO > 7) { return 25; } //error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec
-			if(FDICT != 0) { return 26; } //error: the specification of PNG says about the zlib stream: "The additional flags shall not specify a preset dictionary."
-			inflator.inflate(out, in, 2);
-			return inflator.error; //note: adler32 checksum was skipped and ignored
-		}
-	};
-	struct PNG //nested functions for PNG decoding
-	{
-		struct Info
-		{
-			unsigned long width, height, colorType, bitDepth, compressionMethod, filterMethod, interlaceMethod, key_r, key_g, key_b;
-			bool key_defined; //is a transparent color key given?
-			std::vector<unsigned char> palette;
-		} info;
-		int error;
-		void decode(std::vector<unsigned char>& out, const unsigned char* in, size_t size, bool convert_to_rgba32)
-		{
-			error = 0;
-			if(size == 0 || in == 0) { error = 48; return; } //the given data is empty
-			readPngHeader(&in[0], size); if(error) return;
-			size_t pos = 33; //first byte of the first chunk after the header
-			std::vector<unsigned char> idat; //the data from idat chunks
-			bool IEND = false, known_type = true;
-			info.key_defined = false;
-			while(!IEND) //loop through the chunks, ignoring unknown chunks and stopping at IEND chunk. IDAT data is put at the start of the in buffer
-			{
-				if(pos + 8 >= size) { error = 30; return; } //error: size of the in buffer too small to contain next chunk
-				size_t chunkLength = read32bitInt(&in[pos]); pos += 4;
-				if(chunkLength > 2147483647) { error = 63; return; }
-				if(pos + chunkLength >= size) { error = 35; return; } //error: size of the in buffer too small to contain next chunk
-				if(in[pos + 0] == 'I' && in[pos + 1] == 'D' && in[pos + 2] == 'A' && in[pos + 3] == 'T') //IDAT chunk, containing compressed image data
-				{
-					idat.insert(idat.end(), &in[pos + 4], &in[pos + 4 + chunkLength]);
-					pos += (4 + chunkLength);
-				}
-				else if(in[pos + 0] == 'I' && in[pos + 1] == 'E' && in[pos + 2] == 'N' && in[pos + 3] == 'D')  { pos += 4; IEND = true; }
-				else if(in[pos + 0] == 'P' && in[pos + 1] == 'L' && in[pos + 2] == 'T' && in[pos + 3] == 'E') //palette chunk (PLTE)
-				{
-					pos += 4; //go after the 4 letters
-					info.palette.resize(4 * (chunkLength / 3));
-					if(info.palette.size() > (4 * 256)) { error = 38; return; } //error: palette too big
-					for(size_t i = 0; i < info.palette.size(); i += 4)
-					{
-						for(size_t j = 0; j < 3; j++) info.palette[i + j] = in[pos++]; //RGB
-						info.palette[i + 3] = 255; //alpha
-					}
-				}
-				else if(in[pos + 0] == 't' && in[pos + 1] == 'R' && in[pos + 2] == 'N' && in[pos + 3] == 'S') //palette transparency chunk (tRNS)
-				{
-					pos += 4; //go after the 4 letters
-					if(info.colorType == 3)
-					{
-						if(4 * chunkLength > info.palette.size()) { error = 39; return; } //error: more alpha values given than there are palette entries
-						for(size_t i = 0; i < chunkLength; i++) info.palette[4 * i + 3] = in[pos++];
-					}
-					else if(info.colorType == 0)
-					{
-						if(chunkLength != 2) { error = 40; return; } //error: this chunk must be 2 bytes for greyscale image
-						info.key_defined = 1; info.key_r = info.key_g = info.key_b = 256 * in[pos] + in[pos + 1]; pos += 2;
-					}
-					else if(info.colorType == 2)
-					{
-						if(chunkLength != 6) { error = 41; return; } //error: this chunk must be 6 bytes for RGB image
-						info.key_defined = 1;
-						info.key_r = 256 * in[pos] + in[pos + 1]; pos += 2;
-						info.key_g = 256 * in[pos] + in[pos + 1]; pos += 2;
-						info.key_b = 256 * in[pos] + in[pos + 1]; pos += 2;
-					}
-					else { error = 42; return; } //error: tRNS chunk not allowed for other color models
-				}
-				else //it's not an implemented chunk type, so ignore it: skip over the data
-				{
-					if(!(in[pos + 0] & 32)) { error = 69; return; } //error: unknown critical chunk (5th bit of first byte of chunk type is 0)
-					pos += (chunkLength + 4); //skip 4 letters and uninterpreted data of unimplemented chunk
-					known_type = false;
-				}
-				pos += 4; //step over CRC (which is ignored)
-			}
-			unsigned long bpp = getBpp(info);
-			std::vector<unsigned char> scanlines(((info.width * (info.height * bpp + 7)) / 8) + info.height); //now the out buffer will be filled
-			Zlib zlib; //decompress with the Zlib decompressor
-			error = zlib.decompress(scanlines, idat); if(error) return; //stop if the zlib decompressor returned an error
-			size_t bytewidth = (bpp + 7) / 8, outlength = (info.height * info.width * bpp + 7) / 8;
-			out.resize(outlength); //time to fill the out buffer
-			unsigned char* out_ = outlength ? &out[0] : 0; //use a regular pointer to the std::vector for faster code if compiled without optimization
-			if(info.interlaceMethod == 0) //no interlace, just filter
-			{
-				size_t linestart = 0, linelength = (info.width * bpp + 7) / 8; //length in bytes of a scanline, excluding the filtertype byte
-				if(bpp >= 8) //byte per byte
-					for(unsigned long y = 0; y < info.height; y++)
-					{
-						unsigned long filterType = scanlines[linestart];
-						const unsigned char* prevline = (y == 0) ? 0 : &out_[(y - 1) * info.width * bytewidth];
-						unFilterScanline(&out_[linestart - y], &scanlines[linestart + 1], prevline, bytewidth, filterType,  linelength); if(error) return;
-						linestart += (1 + linelength); //go to start of next scanline
-					}
-				else //less than 8 bits per pixel, so fill it up bit per bit
-				{
-					std::vector<unsigned char> templine((info.width * bpp + 7) >> 3); //only used if bpp < 8
-					for(size_t y = 0, obp = 0; y < info.height; y++)
-					{
-						unsigned long filterType = scanlines[linestart];
-						const unsigned char* prevline = (y == 0) ? 0 : &out_[(y - 1) * info.width * bytewidth];
-						unFilterScanline(&templine[0], &scanlines[linestart + 1], prevline, bytewidth, filterType, linelength); if(error) return;
-						for(size_t bp = 0; bp < info.width * bpp;) setBitOfReversedStream(obp, out_, readBitFromReversedStream(bp, &templine[0]));
-						linestart += (1 + linelength); //go to start of next scanline
-					}
-				}
-			}
-			else //interlaceMethod is 1 (Adam7)
-			{
-				size_t passw[7] = { (info.width + 7) / 8, (info.width + 3) / 8, (info.width + 3) / 4, (info.width + 1) / 4, (info.width + 1) / 2, (info.width + 0) / 2, (info.width + 0) / 1 };
-				size_t passh[7] = { (info.height + 7) / 8, (info.height + 7) / 8, (info.height + 3) / 8, (info.height + 3) / 4, (info.height + 1) / 4, (info.height + 1) / 2, (info.height + 0) / 2 };
-				size_t passstart[7] = {0};
-				size_t pattern[28] = {0,4,0,2,0,1,0,0,0,4,0,2,0,1,8,8,4,4,2,2,1,8,8,8,4,4,2,2}; //values for the adam7 passes
-				for(int i = 0; i < 6; i++) passstart[i + 1] = passstart[i] + passh[i] * ((passw[i] ? 1 : 0) + (passw[i] * bpp + 7) / 8);
-				std::vector<unsigned char> scanlineo((info.width * bpp + 7) / 8), scanlinen((info.width * bpp + 7) / 8); //"old" and "new" scanline
-				for(int i = 0; i < 7; i++)
-					adam7Pass(&out_[0], &scanlinen[0], &scanlineo[0], &scanlines[passstart[i]], info.width, pattern[i], pattern[i + 7], pattern[i + 14], pattern[i + 21], passw[i], passh[i], bpp);
-			}
-			if(convert_to_rgba32 && (info.colorType != 6 || info.bitDepth != 8)) //conversion needed
-			{
-				std::vector<unsigned char> data = out;
-				error = convert(out, &data[0], info, info.width, info.height);
-			}
-		}
-		void readPngHeader(const unsigned char* in, size_t inlength) //read the information from the header and store it in the Info
-		{
-			if(inlength < 29) { error = 27; return; } //error: the data length is smaller than the length of the header
-			if(in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 || in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) { error = 28; return; } //no PNG signature
-			if(in[12] != 'I' || in[13] != 'H' || in[14] != 'D' || in[15] != 'R') { error = 29; return; } //error: it doesn't start with a IHDR chunk!
-			info.width = read32bitInt(&in[16]); info.height = read32bitInt(&in[20]);
-			info.bitDepth = in[24]; info.colorType = in[25];
-			info.compressionMethod = in[26]; if(in[26] != 0) { error = 32; return; } //error: only compression method 0 is allowed in the specification
-			info.filterMethod = in[27]; if(in[27] != 0) { error = 33; return; } //error: only filter method 0 is allowed in the specification
-			info.interlaceMethod = in[28]; if(in[28] > 1) { error = 34; return; } //error: only interlace methods 0 and 1 exist in the specification
-			error = checkColorValidity(info.colorType, info.bitDepth);
-		}
-		void unFilterScanline(unsigned char* recon, const unsigned char* scanline, const unsigned char* precon, size_t bytewidth, unsigned long filterType, size_t length)
-		{
-			switch(filterType)
-			{
-			case 0: for(size_t i = 0; i < length; i++) recon[i] = scanline[i]; break;
-			case 1:
-				for(size_t i =         0; i < bytewidth; i++) recon[i] = scanline[i];
-				for(size_t i = bytewidth; i <    length; i++) recon[i] = scanline[i] + recon[i - bytewidth];
-				break;
-			case 2:
-				if(precon) for(size_t i = 0; i < length; i++) recon[i] = scanline[i] + precon[i];
-				else       for(size_t i = 0; i < length; i++) recon[i] = scanline[i];
-				break;
-			case 3:
-				if(precon)
-				{
-					for(size_t i =         0; i < bytewidth; i++) recon[i] = scanline[i] + precon[i] / 2;
-					for(size_t i = bytewidth; i <    length; i++) recon[i] = scanline[i] + ((recon[i - bytewidth] + precon[i]) / 2);
-				}
-				else
-				{
-					for(size_t i =         0; i < bytewidth; i++) recon[i] = scanline[i];
-					for(size_t i = bytewidth; i <    length; i++) recon[i] = scanline[i] + recon[i - bytewidth] / 2;
-				}
-				break;
-			case 4:
-				if(precon)
-				{
-					for(size_t i =         0; i < bytewidth; i++) recon[i] = scanline[i] + paethPredictor(0, precon[i], 0);
-					for(size_t i = bytewidth; i <    length; i++) recon[i] = scanline[i] + paethPredictor(recon[i - bytewidth], precon[i], precon[i - bytewidth]);
-				}
-				else
-				{
-					for(size_t i =         0; i < bytewidth; i++) recon[i] = scanline[i];
-					for(size_t i = bytewidth; i <    length; i++) recon[i] = scanline[i] + paethPredictor(recon[i - bytewidth], 0, 0);
-				}
-				break;
-			default: error = 36; return; //error: unexisting filter type given
-			}
-		}
-		void adam7Pass(unsigned char* out, unsigned char* linen, unsigned char* lineo, const unsigned char* in, unsigned long w, size_t passleft, size_t passtop, size_t spacex, size_t spacey, size_t passw, size_t passh, unsigned long bpp)
-		{ //filter and reposition the pixels into the output when the image is Adam7 interlaced. This function can only do it after the full image is already decoded. The out buffer must have the correct allocated memory size already.
-			if(passw == 0) return;
-			size_t bytewidth = (bpp + 7) / 8, linelength = 1 + ((bpp * passw + 7) / 8);
-			for(unsigned long y = 0; y < passh; y++)
-			{
-				unsigned char filterType = in[y * linelength], *prevline = (y == 0) ? 0 : lineo;
-				unFilterScanline(linen, &in[y * linelength + 1], prevline, bytewidth, filterType, (w * bpp + 7) / 8); if(error) return;
-				if(bpp >= 8) for(size_t i = 0; i < passw; i++) for(size_t b = 0; b < bytewidth; b++) //b = current byte of this pixel
-					                                               out[bytewidth * w * (passtop + spacey * y) + bytewidth * (passleft + spacex * i) + b] = linen[bytewidth * i + b];
-				else for(size_t i = 0; i < passw; i++)
-				     {
-					     size_t obp = bpp * w * (passtop + spacey * y) + bpp * (passleft + spacex * i), bp = i * bpp;
-					     for(size_t b = 0; b < bpp; b++) setBitOfReversedStream(obp, out, readBitFromReversedStream(bp, &linen[0]));
-				     }
-				unsigned char* temp = linen; linen = lineo; lineo = temp; //swap the two buffer pointers "line old" and "line new"
-			}
-		}
-		static unsigned long readBitFromReversedStream(size_t& bitp, const unsigned char* bits) { unsigned long result = (bits[bitp >> 3] >> (7 - (bitp & 0x7))) & 1; bitp++; return result;}
-		static unsigned long readBitsFromReversedStream(size_t& bitp, const unsigned char* bits, unsigned long nbits)
-		{
-			unsigned long result = 0;
-			for(size_t i = nbits - 1; i < nbits; i--) result += ((readBitFromReversedStream(bitp, bits)) << i);
-			return result;
-		}
-		void setBitOfReversedStream(size_t& bitp, unsigned char* bits, unsigned long bit) { bits[bitp >> 3] |=  (bit << (7 - (bitp & 0x7))); bitp++; }
-		unsigned long read32bitInt(const unsigned char* buffer) { return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]; }
-		int checkColorValidity(unsigned long colorType, unsigned long bd) //return type is a LodePNG error code
-		{
-			if((colorType == 2 || colorType == 4 || colorType == 6)) { if(!(bd == 8 || bd == 16)) return 37; else return 0; }
-			else if(colorType == 0) { if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) return 37; else return 0; }
-			else if(colorType == 3) { if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8            )) return 37; else return 0; }
-			else return 31; //unexisting color type
-		}
-		unsigned long getBpp(const Info& info)
-		{
-			if(info.colorType == 2) return (3 * info.bitDepth);
-			else if(info.colorType >= 4) return (info.colorType - 2) * info.bitDepth;
-			else return info.bitDepth;
-		}
-		int convert(std::vector<unsigned char>& out, const unsigned char* in, Info& infoIn, unsigned long w, unsigned long h)
-		{ //converts from any color type to 32-bit. return value = LodePNG error code
-			size_t numpixels = w * h, bp = 0;
-			out.resize(numpixels * 4);
-			unsigned char* out_ = out.empty() ? 0 : &out[0]; //faster if compiled without optimization
-			if(infoIn.bitDepth == 8 && infoIn.colorType == 0) //greyscale
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[i];
-					out_[4 * i + 3] = (infoIn.key_defined && in[i] == infoIn.key_r) ? 0 : 255;
-				}
-			else if(infoIn.bitDepth == 8 && infoIn.colorType == 2) //RGB color
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					for(size_t c = 0; c < 3; c++) out_[4 * i + c] = in[3 * i + c];
-					out_[4 * i + 3] = (infoIn.key_defined == 1 && in[3 * i + 0] == infoIn.key_r && in[3 * i + 1] == infoIn.key_g && in[3 * i + 2] == infoIn.key_b) ? 0 : 255;
-				}
-			else if(infoIn.bitDepth == 8 && infoIn.colorType == 3) //indexed color (palette)
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					if(4U * in[i] >= infoIn.palette.size()) return 46;
-					for(size_t c = 0; c < 4; c++) out_[4 * i + c] = infoIn.palette[4 * in[i] + c]; //get rgb colors from the palette
-				}
-			else if(infoIn.bitDepth == 8 && infoIn.colorType == 4) //greyscale with alpha
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[2 * i + 0];
-					out_[4 * i + 3] = in[2 * i + 1];
-				}
-			else if(infoIn.bitDepth == 8 && infoIn.colorType == 6) for(size_t i = 0; i < numpixels; i++) for(size_t c = 0; c < 4; c++) out_[4 * i + c] = in[4 * i + c]; //RGB with alpha
-			else if(infoIn.bitDepth == 16 && infoIn.colorType == 0) //greyscale
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[2 * i];
-					out_[4 * i + 3] = (infoIn.key_defined && 256U * in[i] + in[i + 1] == infoIn.key_r) ? 0 : 255;
-				}
-			else if(infoIn.bitDepth == 16 && infoIn.colorType == 2) //RGB color
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					for(size_t c = 0; c < 3; c++) out_[4 * i + c] = in[6 * i + 2 * c];
-					out_[4 * i + 3] = (infoIn.key_defined && 256U*in[6*i+0]+in[6*i+1] == infoIn.key_r && 256U*in[6*i+2]+in[6*i+3] == infoIn.key_g && 256U*in[6*i+4]+in[6*i+5] == infoIn.key_b) ? 0 : 255;
-				}
-			else if(infoIn.bitDepth == 16 && infoIn.colorType == 4) //greyscale with alpha
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[4 * i]; //most significant byte
-					out_[4 * i + 3] = in[4 * i + 2];
-				}
-			else if(infoIn.bitDepth == 16 && infoIn.colorType == 6) for(size_t i = 0; i < numpixels; i++) for(size_t c = 0; c < 4; c++) out_[4 * i + c] = in[8 * i + 2 * c]; //RGB with alpha
-			else if(infoIn.bitDepth < 8 && infoIn.colorType == 0) //greyscale
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					unsigned long value = (readBitsFromReversedStream(bp, in, infoIn.bitDepth) * 255) / ((1 << infoIn.bitDepth) - 1); //scale value from 0 to 255
-					out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = (unsigned char)(value);
-					out_[4 * i + 3] = (infoIn.key_defined && value && ((1U << infoIn.bitDepth) - 1U) == infoIn.key_r && ((1U << infoIn.bitDepth) - 1U)) ? 0 : 255;
-				}
-			else if(infoIn.bitDepth < 8 && infoIn.colorType == 3) //palette
-				for(size_t i = 0; i < numpixels; i++)
-				{
-					unsigned long value = readBitsFromReversedStream(bp, in, infoIn.bitDepth);
-					if(4 * value >= infoIn.palette.size()) return 47;
-					for(size_t c = 0; c < 4; c++) out_[4 * i + c] = infoIn.palette[4 * value + c]; //get rgb colors from the palette
-				}
-			return 0;
-		}
-		unsigned char paethPredictor(short a, short b, short c) //Paeth predicter, used by PNG filter type 4
-		{
-			short p = a + b - c, pa = p > a ? (p - a) : (a - p), pb = p > b ? (p - b) : (b - p), pc = p > c ? (p - c) : (c - p);
-			return (unsigned char)((pa <= pb && pa <= pc) ? a : pb <= pc ? b : c);
-		}
-	};
-	PNG decoder; decoder.decode(out_image, in_png, in_size, convert_to_rgba32);
-	image_width = decoder.info.width; image_height = decoder.info.height;
-	return decoder.error;
+int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width,
+              unsigned long& image_height, const unsigned char* in_png,
+              size_t in_size, bool convert_to_rgba32) {
+    // picoPNG version 20101224
+    // Copyright (c) 2005-2010 Lode Vandevenne
+    //
+    // 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.
+
+    // picoPNG is a PNG decoder in one C++ function of around 500 lines. Use
+    // picoPNG for
+    // programs that need only 1 .cpp file. Since it's a single function, it's
+    // very limited,
+    // it can convert a PNG to raw pixel data either converted to 32-bit RGBA
+    // color or
+    // with no color conversion at all. For anything more complex, another tiny
+    // library
+    // is available: LodePNG (lodepng.c(pp)), which is a single source and
+    // header file.
+    // Apologies for the compact code style, it's to make this tiny.
+
+    static const unsigned long LENBASE[29] = {
+        3,  4,  5,  6,  7,  8,  9,  10, 11,  13,  15,  17,  19,  23, 27,
+        31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258};
+    static const unsigned long LENEXTRA[29] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+                                               1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
+                                               4, 4, 4, 4, 5, 5, 5, 5, 0};
+    static const unsigned long DISTBASE[30] = {
+        1,    2,    3,    4,    5,    7,    9,    13,    17,    25,
+        33,   49,   65,   97,   129,  193,  257,  385,   513,   769,
+        1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577};
+    static const unsigned long DISTEXTRA[30] = {
+        0, 0, 0, 0, 1, 1, 2, 2,  3,  3,  4,  4,  5,  5,  6,
+        6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
+    static const unsigned long CLCL[19] = {
+        16, 17, 18, 0, 8,  7, 9,  6, 10, 5,
+        11, 4,  12, 3, 13, 2, 14, 1, 15};  // code length code lengths
+    struct Zlib  // nested functions for zlib decompression
+    {
+        static unsigned long readBitFromStream(size_t& bitp,
+                                               const unsigned char* bits) {
+            unsigned long result = (bits[bitp >> 3] >> (bitp & 0x7)) & 1;
+            bitp++;
+            return result;
+        }
+        static unsigned long readBitsFromStream(size_t& bitp,
+                                                const unsigned char* bits,
+                                                size_t nbits) {
+            unsigned long result = 0;
+            for (size_t i = 0; i < nbits; i++)
+                result += (readBitFromStream(bitp, bits)) << i;
+            return result;
+        }
+        struct HuffmanTree {
+            int makeFromLengths(
+                const std::vector<unsigned long>& bitlen,
+                unsigned long maxbitlen) {  // make tree given the lengths
+                unsigned long numcodes = (unsigned long)(bitlen.size()),
+                              treepos = 0, nodefilled = 0;
+                std::vector<unsigned long> tree1d(numcodes),
+                    blcount(maxbitlen + 1, 0), nextcode(maxbitlen + 1, 0);
+                for (unsigned long bits = 0; bits < numcodes; bits++)
+                    blcount[bitlen[bits]]++;  // count number of instances of
+                                              // each code length
+                for (unsigned long bits = 1; bits <= maxbitlen; bits++)
+                    nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1])
+                                     << 1;
+                for (unsigned long n = 0; n < numcodes; n++)
+                    if (bitlen[n] != 0)
+                        tree1d[n] =
+                            nextcode[bitlen[n]]++;  // generate all the codes
+                tree2d.clear();
+                tree2d.resize(numcodes * 2, 32767);  // 32767 here means the
+                                                     // tree2d isn't filled
+                                                     // there yet
+                for (unsigned long n = 0; n < numcodes; n++)  // the codes
+                    for (unsigned long i = 0; i < bitlen[n];
+                         i++)  // the bits for this code
+                    {
+                        unsigned long bit =
+                            (tree1d[n] >> (bitlen[n] - i - 1)) & 1;
+                        if (treepos > numcodes - 2) return 55;
+                        if (tree2d[2 * treepos + bit] ==
+                            32767)  // not yet filled in
+                        {
+                            if (i + 1 == bitlen[n]) {
+                                tree2d[2 * treepos + bit] = n;
+                                treepos = 0;
+                            }  // last bit
+                            else {
+                                tree2d[2 * treepos + bit] =
+                                    ++nodefilled + numcodes;
+                                treepos = nodefilled;
+                            }  // addresses are encoded as values > numcodes
+                        } else
+                            treepos = tree2d[2 * treepos + bit] -
+                                      numcodes;  // subtract numcodes from
+                                                 // address to get address value
+                    }
+                return 0;
+            }
+            int decode(
+                bool& decoded, unsigned long& result, size_t& treepos,
+                unsigned long bit) const {  // Decodes a symbol from the tree
+                unsigned long numcodes = (unsigned long)tree2d.size() / 2;
+                if (treepos >= numcodes)
+                    return 11;  // error: you appeared outside the codetree
+                result = tree2d[2 * treepos + bit];
+                decoded = (result < numcodes);
+                treepos = decoded ? 0 : result - numcodes;
+                return 0;
+            }
+            std::vector<unsigned long> tree2d;  // 2D representation of a
+                                                // huffman tree: The one
+                                                // dimension is "0" or "1", the
+                                                // other contains all nodes and
+                                                // leaves of the tree.
+        };
+        struct Inflator {
+            int error;
+            void inflate(std::vector<unsigned char>& out,
+                         const std::vector<unsigned char>& in,
+                         size_t inpos = 0) {
+                size_t bp = 0, pos = 0;  // bit pointer and byte pointer
+                error = 0;
+                unsigned long BFINAL = 0;
+                while (!BFINAL && !error) {
+                    if (bp >> 3 >= in.size()) {
+                        error = 52;
+                        return;
+                    }  // error, bit pointer will jump past memory
+                    BFINAL = readBitFromStream(bp, &in[inpos]);
+                    unsigned long BTYPE = readBitFromStream(bp, &in[inpos]);
+                    BTYPE += 2 * readBitFromStream(bp, &in[inpos]);
+                    if (BTYPE == 3) {
+                        error = 20;
+                        return;
+                    }  // error: invalid BTYPE
+                    else if (BTYPE == 0)
+                        inflateNoCompression(out, &in[inpos], bp, pos,
+                                             in.size());
+                    else
+                        inflateHuffmanBlock(out, &in[inpos], bp, pos, in.size(),
+                                            BTYPE);
+                }
+                if (!error)
+                    out.resize(pos);  // Only now we know the true size of out,
+                                      // resize it to that
+            }
+            void generateFixedTrees(HuffmanTree& tree,
+                                    HuffmanTree& treeD)  // get the tree of a
+                                                         // deflated block with
+                                                         // fixed tree
+            {
+                std::vector<unsigned long> bitlen(288, 8), bitlenD(32, 5);
+                ;
+                for (size_t i = 144; i <= 255; i++) bitlen[i] = 9;
+                for (size_t i = 256; i <= 279; i++) bitlen[i] = 7;
+                tree.makeFromLengths(bitlen, 15);
+                treeD.makeFromLengths(bitlenD, 15);
+            }
+            HuffmanTree codetree, codetreeD,
+                codelengthcodetree;  // the code tree for Huffman codes, dist
+                                     // codes, and code length codes
+            unsigned long huffmanDecodeSymbol(
+                const unsigned char* in, size_t& bp,
+                const HuffmanTree& codetree,
+                size_t inlength) {  // decode a single symbol from given list of
+                                    // bits with given code tree. return value
+                                    // is the symbol
+                bool decoded;
+                unsigned long ct;
+                for (size_t treepos = 0;;) {
+                    if ((bp & 0x07) == 0 && (bp >> 3) > inlength) {
+                        error = 10;
+                        return 0;
+                    }  // error: end reached without endcode
+                    error = codetree.decode(decoded, ct, treepos,
+                                            readBitFromStream(bp, in));
+                    if (error) return 0;  // stop, an error happened
+                    if (decoded) return ct;
+                }
+            }
+            void getTreeInflateDynamic(
+                HuffmanTree& tree, HuffmanTree& treeD, const unsigned char* in,
+                size_t& bp,
+                size_t inlength) {  // get the tree of a deflated block with
+                                    // dynamic tree, the tree itself is also
+                                    // Huffman compressed with a known tree
+                std::vector<unsigned long> bitlen(288, 0), bitlenD(32, 0);
+                if (bp >> 3 >= inlength - 2) {
+                    error = 49;
+                    return;
+                }  // the bit pointer is or will go past the memory
+                size_t HLIT = readBitsFromStream(bp, in, 5) +
+                              257;  // number of literal/length codes + 257
+                size_t HDIST = readBitsFromStream(bp, in, 5) +
+                               1;  // number of dist codes + 1
+                size_t HCLEN = readBitsFromStream(bp, in, 4) +
+                               4;  // number of code length codes + 4
+                std::vector<unsigned long> codelengthcode(
+                    19);  // lengths of tree to decode the lengths of the
+                          // dynamic tree
+                for (size_t i = 0; i < 19; i++)
+                    codelengthcode[CLCL[i]] =
+                        (i < HCLEN) ? readBitsFromStream(bp, in, 3) : 0;
+                error = codelengthcodetree.makeFromLengths(codelengthcode, 7);
+                if (error) return;
+                size_t i = 0, replength;
+                while (i < HLIT + HDIST) {
+                    unsigned long code = huffmanDecodeSymbol(
+                        in, bp, codelengthcodetree, inlength);
+                    if (error) return;
+                    if (code <= 15) {
+                        if (i < HLIT)
+                            bitlen[i++] = code;
+                        else
+                            bitlenD[i++ - HLIT] = code;
+                    }                     // a length code
+                    else if (code == 16)  // repeat previous
+                    {
+                        if (bp >> 3 >= inlength) {
+                            error = 50;
+                            return;
+                        }  // error, bit pointer jumps past memory
+                        replength = 3 + readBitsFromStream(bp, in, 2);
+                        unsigned long value;  // set value to the previous code
+                        if ((i - 1) < HLIT)
+                            value = bitlen[i - 1];
+                        else
+                            value = bitlenD[i - HLIT - 1];
+                        for (size_t n = 0; n < replength;
+                             n++)  // repeat this value in the next lengths
+                        {
+                            if (i >= HLIT + HDIST) {
+                                error = 13;
+                                return;
+                            }  // error: i is larger than the amount of codes
+                            if (i < HLIT)
+                                bitlen[i++] = value;
+                            else
+                                bitlenD[i++ - HLIT] = value;
+                        }
+                    } else if (code == 17)  // repeat "0" 3-10 times
+                    {
+                        if (bp >> 3 >= inlength) {
+                            error = 50;
+                            return;
+                        }  // error, bit pointer jumps past memory
+                        replength = 3 + readBitsFromStream(bp, in, 3);
+                        for (size_t n = 0; n < replength;
+                             n++)  // repeat this value in the next lengths
+                        {
+                            if (i >= HLIT + HDIST) {
+                                error = 14;
+                                return;
+                            }  // error: i is larger than the amount of codes
+                            if (i < HLIT)
+                                bitlen[i++] = 0;
+                            else
+                                bitlenD[i++ - HLIT] = 0;
+                        }
+                    } else if (code == 18)  // repeat "0" 11-138 times
+                    {
+                        if (bp >> 3 >= inlength) {
+                            error = 50;
+                            return;
+                        }  // error, bit pointer jumps past memory
+                        replength = 11 + readBitsFromStream(bp, in, 7);
+                        for (size_t n = 0; n < replength;
+                             n++)  // repeat this value in the next lengths
+                        {
+                            if (i >= HLIT + HDIST) {
+                                error = 15;
+                                return;
+                            }  // error: i is larger than the amount of codes
+                            if (i < HLIT)
+                                bitlen[i++] = 0;
+                            else
+                                bitlenD[i++ - HLIT] = 0;
+                        }
+                    } else {
+                        error = 16;
+                        return;
+                    }  // error: somehow an unexisting code appeared. This can
+                       // never happen.
+                }
+                if (bitlen[256] == 0) {
+                    error = 64;
+                    return;
+                }  // the length of the end code 256 must be larger than 0
+                error = tree.makeFromLengths(bitlen, 15);
+                if (error)
+                    return;  // now we've finally got HLIT and HDIST, so
+                             // generate the code trees, and the function is
+                             // done
+                error = treeD.makeFromLengths(bitlenD, 15);
+                if (error) return;
+            }
+            void inflateHuffmanBlock(std::vector<unsigned char>& out,
+                                     const unsigned char* in, size_t& bp,
+                                     size_t& pos, size_t inlength,
+                                     unsigned long btype) {
+                if (btype == 1) {
+                    generateFixedTrees(codetree, codetreeD);
+                } else if (btype == 2) {
+                    getTreeInflateDynamic(codetree, codetreeD, in, bp,
+                                          inlength);
+                    if (error) return;
+                }
+                for (;;) {
+                    unsigned long code =
+                        huffmanDecodeSymbol(in, bp, codetree, inlength);
+                    if (error) return;
+                    if (code == 256)
+                        return;            // end code
+                    else if (code <= 255)  // literal symbol
+                    {
+                        if (pos >= out.size())
+                            out.resize((pos + 1) * 2);  // reserve more room
+                        out[pos++] = (unsigned char)(code);
+                    } else if (code >= 257 && code <= 285)  // length code
+                    {
+                        size_t length = LENBASE[code - 257],
+                               numextrabits = LENEXTRA[code - 257];
+                        if ((bp >> 3) >= inlength) {
+                            error = 51;
+                            return;
+                        }  // error, bit pointer will jump past memory
+                        length += readBitsFromStream(bp, in, numextrabits);
+                        unsigned long codeD =
+                            huffmanDecodeSymbol(in, bp, codetreeD, inlength);
+                        if (error) return;
+                        if (codeD > 29) {
+                            error = 18;
+                            return;
+                        }  // error: invalid dist code (30-31 are never used)
+                        unsigned long dist = DISTBASE[codeD],
+                                      numextrabitsD = DISTEXTRA[codeD];
+                        if ((bp >> 3) >= inlength) {
+                            error = 51;
+                            return;
+                        }  // error, bit pointer will jump past memory
+                        dist += readBitsFromStream(bp, in, numextrabitsD);
+                        size_t start = pos, back = start - dist;  // backwards
+                        if (pos + length >= out.size())
+                            out.resize((pos + length) * 2);  // reserve more
+                                                             // room
+                        for (size_t i = 0; i < length; i++) {
+                            out[pos++] = out[back++];
+                            if (back >= start) back = start - dist;
+                        }
+                    }
+                }
+            }
+            void inflateNoCompression(std::vector<unsigned char>& out,
+                                      const unsigned char* in, size_t& bp,
+                                      size_t& pos, size_t inlength) {
+                while ((bp & 0x7) != 0) bp++;  // go to first boundary of byte
+                size_t p = bp / 8;
+                if (p >= inlength - 4) {
+                    error = 52;
+                    return;
+                }  // error, bit pointer will jump past memory
+                unsigned long LEN = in[p] + 256 * in[p + 1],
+                              NLEN = in[p + 2] + 256 * in[p + 3];
+                p += 4;
+                if (LEN + NLEN != 65535) {
+                    error = 21;
+                    return;
+                }  // error: NLEN is not one's complement of LEN
+                if (pos + LEN >= out.size()) out.resize(pos + LEN);
+                if (p + LEN > inlength) {
+                    error = 23;
+                    return;
+                }  // error: reading outside of in buffer
+                for (unsigned long n = 0; n < LEN; n++)
+                    out[pos++] = in[p++];  // read LEN bytes of literal data
+                bp = p * 8;
+            }
+        };
+        int decompress(
+            std::vector<unsigned char>& out,
+            const std::vector<unsigned char>& in)  // returns error value
+        {
+            Inflator inflator;
+            if (in.size() < 2) {
+                return 53;
+            }  // error, size of zlib data too small
+            if ((in[0] * 256 + in[1]) % 31 != 0) {
+                return 24;
+            }  // error: 256 * in[0] + in[1] must be a multiple of 31, the
+               // FCHECK value is supposed to be made that way
+            unsigned long CM = in[0] & 15, CINFO = (in[0] >> 4) & 15,
+                          FDICT = (in[1] >> 5) & 1;
+            if (CM != 8 || CINFO > 7) {
+                return 25;
+            }  // error: only compression method 8: inflate with sliding window
+               // of 32k is supported by the PNG spec
+            if (FDICT != 0) {
+                return 26;
+            }  // error: the specification of PNG says about the zlib stream:
+               // "The additional flags shall not specify a preset dictionary."
+            inflator.inflate(out, in, 2);
+            return inflator
+                .error;  // note: adler32 checksum was skipped and ignored
+        }
+    };
+    struct PNG  // nested functions for PNG decoding
+    {
+        struct Info {
+            unsigned long width, height, colorType, bitDepth, compressionMethod,
+                filterMethod, interlaceMethod, key_r, key_g, key_b;
+            bool key_defined;  // is a transparent color key given?
+            std::vector<unsigned char> palette;
+        } info;
+        int error;
+        void decode(std::vector<unsigned char>& out, const unsigned char* in,
+                    size_t size, bool convert_to_rgba32) {
+            error = 0;
+            if (size == 0 || in == 0) {
+                error = 48;
+                return;
+            }  // the given data is empty
+            readPngHeader(&in[0], size);
+            if (error) return;
+            size_t pos = 33;  // first byte of the first chunk after the header
+            std::vector<unsigned char> idat;  // the data from idat chunks
+            bool IEND = false, known_type = true;
+            info.key_defined = false;
+            while (!IEND)  // loop through the chunks, ignoring unknown chunks
+                           // and stopping at IEND chunk. IDAT data is put at
+                           // the start of the in buffer
+            {
+                if (pos + 8 >= size) {
+                    error = 30;
+                    return;
+                }  // error: size of the in buffer too small to contain next
+                   // chunk
+                size_t chunkLength = read32bitInt(&in[pos]);
+                pos += 4;
+                if (chunkLength > 2147483647) {
+                    error = 63;
+                    return;
+                }
+                if (pos + chunkLength >= size) {
+                    error = 35;
+                    return;
+                }  // error: size of the in buffer too small to contain next
+                   // chunk
+                if (in[pos + 0] == 'I' && in[pos + 1] == 'D' &&
+                    in[pos + 2] == 'A' &&
+                    in[pos + 3] ==
+                        'T')  // IDAT chunk, containing compressed image data
+                {
+                    idat.insert(idat.end(), &in[pos + 4],
+                                &in[pos + 4 + chunkLength]);
+                    pos += (4 + chunkLength);
+                } else if (in[pos + 0] == 'I' && in[pos + 1] == 'E' &&
+                           in[pos + 2] == 'N' && in[pos + 3] == 'D') {
+                    pos += 4;
+                    IEND = true;
+                } else if (in[pos + 0] == 'P' && in[pos + 1] == 'L' &&
+                           in[pos + 2] == 'T' &&
+                           in[pos + 3] == 'E')  // palette chunk (PLTE)
+                {
+                    pos += 4;  // go after the 4 letters
+                    info.palette.resize(4 * (chunkLength / 3));
+                    if (info.palette.size() > (4 * 256)) {
+                        error = 38;
+                        return;
+                    }  // error: palette too big
+                    for (size_t i = 0; i < info.palette.size(); i += 4) {
+                        for (size_t j = 0; j < 3; j++)
+                            info.palette[i + j] = in[pos++];  // RGB
+                        info.palette[i + 3] = 255;            // alpha
+                    }
+                } else if (in[pos + 0] == 't' && in[pos + 1] == 'R' &&
+                           in[pos + 2] == 'N' &&
+                           in[pos + 3] ==
+                               'S')  // palette transparency chunk (tRNS)
+                {
+                    pos += 4;  // go after the 4 letters
+                    if (info.colorType == 3) {
+                        if (4 * chunkLength > info.palette.size()) {
+                            error = 39;
+                            return;
+                        }  // error: more alpha values given than there are
+                           // palette entries
+                        for (size_t i = 0; i < chunkLength; i++)
+                            info.palette[4 * i + 3] = in[pos++];
+                    } else if (info.colorType == 0) {
+                        if (chunkLength != 2) {
+                            error = 40;
+                            return;
+                        }  // error: this chunk must be 2 bytes for greyscale
+                           // image
+                        info.key_defined = 1;
+                        info.key_r = info.key_g = info.key_b =
+                            256 * in[pos] + in[pos + 1];
+                        pos += 2;
+                    } else if (info.colorType == 2) {
+                        if (chunkLength != 6) {
+                            error = 41;
+                            return;
+                        }  // error: this chunk must be 6 bytes for RGB image
+                        info.key_defined = 1;
+                        info.key_r = 256 * in[pos] + in[pos + 1];
+                        pos += 2;
+                        info.key_g = 256 * in[pos] + in[pos + 1];
+                        pos += 2;
+                        info.key_b = 256 * in[pos] + in[pos + 1];
+                        pos += 2;
+                    } else {
+                        error = 42;
+                        return;
+                    }   // error: tRNS chunk not allowed for other color models
+                } else  // it's not an implemented chunk type, so ignore it:
+                        // skip over the data
+                {
+                    if (!(in[pos + 0] & 32)) {
+                        error = 69;
+                        return;
+                    }  // error: unknown critical chunk (5th bit of first byte
+                       // of chunk type is 0)
+                    pos += (chunkLength + 4);  // skip 4 letters and
+                                               // uninterpreted data of
+                                               // unimplemented chunk
+                    known_type = false;
+                }
+                pos += 4;  // step over CRC (which is ignored)
+            }
+            unsigned long bpp = getBpp(info);
+            std::vector<unsigned char> scanlines(
+                ((info.width * (info.height * bpp + 7)) / 8) +
+                info.height);  // now the out buffer will be filled
+            Zlib zlib;         // decompress with the Zlib decompressor
+            error = zlib.decompress(scanlines, idat);
+            if (error)
+                return;  // stop if the zlib decompressor returned an error
+            size_t bytewidth = (bpp + 7) / 8,
+                   outlength = (info.height * info.width * bpp + 7) / 8;
+            out.resize(outlength);  // time to fill the out buffer
+            unsigned char* out_ =
+                outlength ? &out[0] : 0;  // use a regular pointer to the
+                                          // std::vector for faster code if
+                                          // compiled without optimization
+            if (info.interlaceMethod == 0)  // no interlace, just filter
+            {
+                size_t linestart = 0,
+                       linelength = (info.width * bpp + 7) /
+                                    8;  // length in bytes of a scanline,
+                                        // excluding the filtertype byte
+                if (bpp >= 8)  // byte per byte
+                    for (unsigned long y = 0; y < info.height; y++) {
+                        unsigned long filterType = scanlines[linestart];
+                        const unsigned char* prevline =
+                            (y == 0) ? 0
+                                     : &out_[(y - 1) * info.width * bytewidth];
+                        unFilterScanline(&out_[linestart - y],
+                                         &scanlines[linestart + 1], prevline,
+                                         bytewidth, filterType, linelength);
+                        if (error) return;
+                        linestart +=
+                            (1 + linelength);  // go to start of next scanline
+                    }
+                else  // less than 8 bits per pixel, so fill it up bit per bit
+                {
+                    std::vector<unsigned char> templine(
+                        (info.width * bpp + 7) >> 3);  // only used if bpp < 8
+                    for (size_t y = 0, obp = 0; y < info.height; y++) {
+                        unsigned long filterType = scanlines[linestart];
+                        const unsigned char* prevline =
+                            (y == 0) ? 0
+                                     : &out_[(y - 1) * info.width * bytewidth];
+                        unFilterScanline(&templine[0],
+                                         &scanlines[linestart + 1], prevline,
+                                         bytewidth, filterType, linelength);
+                        if (error) return;
+                        for (size_t bp = 0; bp < info.width * bpp;)
+                            setBitOfReversedStream(
+                                obp, out_,
+                                readBitFromReversedStream(bp, &templine[0]));
+                        linestart +=
+                            (1 + linelength);  // go to start of next scanline
+                    }
+                }
+            } else  // interlaceMethod is 1 (Adam7)
+            {
+                size_t passw[7] = {(info.width + 7) / 8, (info.width + 3) / 8,
+                                   (info.width + 3) / 4, (info.width + 1) / 4,
+                                   (info.width + 1) / 2, (info.width + 0) / 2,
+                                   (info.width + 0) / 1};
+                size_t passh[7] = {(info.height + 7) / 8, (info.height + 7) / 8,
+                                   (info.height + 3) / 8, (info.height + 3) / 4,
+                                   (info.height + 1) / 4, (info.height + 1) / 2,
+                                   (info.height + 0) / 2};
+                size_t passstart[7] = {0};
+                size_t pattern[28] = {
+                    0, 4, 0, 2, 0, 1, 0, 0, 0, 4, 0, 2, 0, 1, 8,
+                    8, 4, 4, 2, 2, 1, 8, 8, 8, 4, 4, 2, 2};  // values for the
+                                                             // adam7 passes
+                for (int i = 0; i < 6; i++)
+                    passstart[i + 1] = passstart[i] +
+                                       passh[i] * ((passw[i] ? 1 : 0) +
+                                                   (passw[i] * bpp + 7) / 8);
+                std::vector<unsigned char> scanlineo((info.width * bpp + 7) /
+                                                     8),
+                    scanlinen((info.width * bpp + 7) /
+                              8);  //"old" and "new" scanline
+                for (int i = 0; i < 7; i++)
+                    adam7Pass(&out_[0], &scanlinen[0], &scanlineo[0],
+                              &scanlines[passstart[i]], info.width, pattern[i],
+                              pattern[i + 7], pattern[i + 14], pattern[i + 21],
+                              passw[i], passh[i], bpp);
+            }
+            if (convert_to_rgba32 && (info.colorType != 6 ||
+                                      info.bitDepth != 8))  // conversion needed
+            {
+                std::vector<unsigned char> data = out;
+                error = convert(out, &data[0], info, info.width, info.height);
+            }
+        }
+        void readPngHeader(const unsigned char* in,
+                           size_t inlength)  // read the information from the
+                                             // header and store it in the Info
+        {
+            if (inlength < 29) {
+                error = 27;
+                return;
+            }  // error: the data length is smaller than the length of the
+               // header
+            if (in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 ||
+                in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) {
+                error = 28;
+                return;
+            }  // no PNG signature
+            if (in[12] != 'I' || in[13] != 'H' || in[14] != 'D' ||
+                in[15] != 'R') {
+                error = 29;
+                return;
+            }  // error: it doesn't start with a IHDR chunk!
+            info.width = read32bitInt(&in[16]);
+            info.height = read32bitInt(&in[20]);
+            info.bitDepth = in[24];
+            info.colorType = in[25];
+            info.compressionMethod = in[26];
+            if (in[26] != 0) {
+                error = 32;
+                return;
+            }  // error: only compression method 0 is allowed in the
+               // specification
+            info.filterMethod = in[27];
+            if (in[27] != 0) {
+                error = 33;
+                return;
+            }  // error: only filter method 0 is allowed in the specification
+            info.interlaceMethod = in[28];
+            if (in[28] > 1) {
+                error = 34;
+                return;
+            }  // error: only interlace methods 0 and 1 exist in the
+               // specification
+            error = checkColorValidity(info.colorType, info.bitDepth);
+        }
+        void unFilterScanline(unsigned char* recon,
+                              const unsigned char* scanline,
+                              const unsigned char* precon, size_t bytewidth,
+                              unsigned long filterType, size_t length) {
+            switch (filterType) {
+                case 0:
+                    for (size_t i = 0; i < length; i++) recon[i] = scanline[i];
+                    break;
+                case 1:
+                    for (size_t i = 0; i < bytewidth; i++)
+                        recon[i] = scanline[i];
+                    for (size_t i = bytewidth; i < length; i++)
+                        recon[i] = scanline[i] + recon[i - bytewidth];
+                    break;
+                case 2:
+                    if (precon)
+                        for (size_t i = 0; i < length; i++)
+                            recon[i] = scanline[i] + precon[i];
+                    else
+                        for (size_t i = 0; i < length; i++)
+                            recon[i] = scanline[i];
+                    break;
+                case 3:
+                    if (precon) {
+                        for (size_t i = 0; i < bytewidth; i++)
+                            recon[i] = scanline[i] + precon[i] / 2;
+                        for (size_t i = bytewidth; i < length; i++)
+                            recon[i] = scanline[i] +
+                                       ((recon[i - bytewidth] + precon[i]) / 2);
+                    } else {
+                        for (size_t i = 0; i < bytewidth; i++)
+                            recon[i] = scanline[i];
+                        for (size_t i = bytewidth; i < length; i++)
+                            recon[i] = scanline[i] + recon[i - bytewidth] / 2;
+                    }
+                    break;
+                case 4:
+                    if (precon) {
+                        for (size_t i = 0; i < bytewidth; i++)
+                            recon[i] =
+                                scanline[i] + paethPredictor(0, precon[i], 0);
+                        for (size_t i = bytewidth; i < length; i++)
+                            recon[i] =
+                                scanline[i] +
+                                paethPredictor(recon[i - bytewidth], precon[i],
+                                               precon[i - bytewidth]);
+                    } else {
+                        for (size_t i = 0; i < bytewidth; i++)
+                            recon[i] = scanline[i];
+                        for (size_t i = bytewidth; i < length; i++)
+                            recon[i] =
+                                scanline[i] +
+                                paethPredictor(recon[i - bytewidth], 0, 0);
+                    }
+                    break;
+                default:
+                    error = 36;
+                    return;  // error: unexisting filter type given
+            }
+        }
+        void adam7Pass(unsigned char* out, unsigned char* linen,
+                       unsigned char* lineo, const unsigned char* in,
+                       unsigned long w, size_t passleft, size_t passtop,
+                       size_t spacex, size_t spacey, size_t passw, size_t passh,
+                       unsigned long bpp) {  // filter and reposition the pixels
+                                             // into the output when the image
+                                             // is Adam7 interlaced. This
+                                             // function can only do it after
+                                             // the full image is already
+                                             // decoded. The out buffer must
+                                             // have the correct allocated
+                                             // memory size already.
+            if (passw == 0) return;
+            size_t bytewidth = (bpp + 7) / 8,
+                   linelength = 1 + ((bpp * passw + 7) / 8);
+            for (unsigned long y = 0; y < passh; y++) {
+                unsigned char filterType = in[y * linelength],
+                              *prevline = (y == 0) ? 0 : lineo;
+                unFilterScanline(linen, &in[y * linelength + 1], prevline,
+                                 bytewidth, filterType, (w * bpp + 7) / 8);
+                if (error) return;
+                if (bpp >= 8)
+                    for (size_t i = 0; i < passw; i++)
+                        for (size_t b = 0; b < bytewidth;
+                             b++)  // b = current byte of this pixel
+                            out[bytewidth * w * (passtop + spacey * y) +
+                                bytewidth * (passleft + spacex * i) + b] =
+                                linen[bytewidth * i + b];
+                else
+                    for (size_t i = 0; i < passw; i++) {
+                        size_t obp = bpp * w * (passtop + spacey * y) +
+                                     bpp * (passleft + spacex * i),
+                               bp = i * bpp;
+                        for (size_t b = 0; b < bpp; b++)
+                            setBitOfReversedStream(
+                                obp, out,
+                                readBitFromReversedStream(bp, &linen[0]));
+                    }
+                unsigned char* temp = linen;
+                linen = lineo;
+                lineo = temp;  // swap the two buffer pointers "line old" and
+                               // "line new"
+            }
+        }
+        static unsigned long readBitFromReversedStream(
+            size_t& bitp, const unsigned char* bits) {
+            unsigned long result = (bits[bitp >> 3] >> (7 - (bitp & 0x7))) & 1;
+            bitp++;
+            return result;
+        }
+        static unsigned long readBitsFromReversedStream(
+            size_t& bitp, const unsigned char* bits, unsigned long nbits) {
+            unsigned long result = 0;
+            for (size_t i = nbits - 1; i < nbits; i--)
+                result += ((readBitFromReversedStream(bitp, bits)) << i);
+            return result;
+        }
+        void setBitOfReversedStream(size_t& bitp, unsigned char* bits,
+                                    unsigned long bit) {
+            bits[bitp >> 3] |= (bit << (7 - (bitp & 0x7)));
+            bitp++;
+        }
+        unsigned long read32bitInt(const unsigned char* buffer) {
+            return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) |
+                   buffer[3];
+        }
+        int checkColorValidity(
+            unsigned long colorType,
+            unsigned long bd)  // return type is a LodePNG error code
+        {
+            if ((colorType == 2 || colorType == 4 || colorType == 6)) {
+                if (!(bd == 8 || bd == 16))
+                    return 37;
+                else
+                    return 0;
+            } else if (colorType == 0) {
+                if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16))
+                    return 37;
+                else
+                    return 0;
+            } else if (colorType == 3) {
+                if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8))
+                    return 37;
+                else
+                    return 0;
+            } else
+                return 31;  // unexisting color type
+        }
+        unsigned long getBpp(const Info& info) {
+            if (info.colorType == 2)
+                return (3 * info.bitDepth);
+            else if (info.colorType >= 4)
+                return (info.colorType - 2) * info.bitDepth;
+            else
+                return info.bitDepth;
+        }
+        int convert(std::vector<unsigned char>& out, const unsigned char* in,
+                    Info& infoIn, unsigned long w,
+                    unsigned long h) {  // converts from any color type to
+                                        // 32-bit. return value = LodePNG error
+                                        // code
+            size_t numpixels = w * h, bp = 0;
+            out.resize(numpixels * 4);
+            unsigned char* out_ =
+                out.empty()
+                    ? 0
+                    : &out[0];  // faster if compiled without optimization
+            if (infoIn.bitDepth == 8 && infoIn.colorType == 0)  // greyscale
+                for (size_t i = 0; i < numpixels; i++) {
+                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] = in[i];
+                    out_[4 * i + 3] =
+                        (infoIn.key_defined && in[i] == infoIn.key_r) ? 0 : 255;
+                }
+            else if (infoIn.bitDepth == 8 && infoIn.colorType == 2)  // RGB
+                                                                     // color
+                for (size_t i = 0; i < numpixels; i++) {
+                    for (size_t c = 0; c < 3; c++)
+                        out_[4 * i + c] = in[3 * i + c];
+                    out_[4 * i + 3] = (infoIn.key_defined == 1 &&
+                                       in[3 * i + 0] == infoIn.key_r &&
+                                       in[3 * i + 1] == infoIn.key_g &&
+                                       in[3 * i + 2] == infoIn.key_b)
+                                          ? 0
+                                          : 255;
+                }
+            else if (infoIn.bitDepth == 8 &&
+                     infoIn.colorType == 3)  // indexed color (palette)
+                for (size_t i = 0; i < numpixels; i++) {
+                    if (4U * in[i] >= infoIn.palette.size()) return 46;
+                    for (size_t c = 0; c < 4; c++)
+                        out_[4 * i + c] =
+                            infoIn.palette[4 * in[i] + c];  // get rgb colors
+                                                            // from the palette
+                }
+            else if (infoIn.bitDepth == 8 &&
+                     infoIn.colorType == 4)  // greyscale with alpha
+                for (size_t i = 0; i < numpixels; i++) {
+                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
+                        in[2 * i + 0];
+                    out_[4 * i + 3] = in[2 * i + 1];
+                }
+            else if (infoIn.bitDepth == 8 && infoIn.colorType == 6)
+                for (size_t i = 0; i < numpixels; i++)
+                    for (size_t c = 0; c < 4; c++)
+                        out_[4 * i + c] = in[4 * i + c];  // RGB with alpha
+            else if (infoIn.bitDepth == 16 &&
+                     infoIn.colorType == 0)  // greyscale
+                for (size_t i = 0; i < numpixels; i++) {
+                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
+                        in[2 * i];
+                    out_[4 * i + 3] = (infoIn.key_defined &&
+                                       256U * in[i] + in[i + 1] == infoIn.key_r)
+                                          ? 0
+                                          : 255;
+                }
+            else if (infoIn.bitDepth == 16 &&
+                     infoIn.colorType == 2)  // RGB color
+                for (size_t i = 0; i < numpixels; i++) {
+                    for (size_t c = 0; c < 3; c++)
+                        out_[4 * i + c] = in[6 * i + 2 * c];
+                    out_[4 * i + 3] =
+                        (infoIn.key_defined &&
+                         256U * in[6 * i + 0] + in[6 * i + 1] == infoIn.key_r &&
+                         256U * in[6 * i + 2] + in[6 * i + 3] == infoIn.key_g &&
+                         256U * in[6 * i + 4] + in[6 * i + 5] == infoIn.key_b)
+                            ? 0
+                            : 255;
+                }
+            else if (infoIn.bitDepth == 16 &&
+                     infoIn.colorType == 4)  // greyscale with alpha
+                for (size_t i = 0; i < numpixels; i++) {
+                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
+                        in[4 * i];  // most significant byte
+                    out_[4 * i + 3] = in[4 * i + 2];
+                }
+            else if (infoIn.bitDepth == 16 && infoIn.colorType == 6)
+                for (size_t i = 0; i < numpixels; i++)
+                    for (size_t c = 0; c < 4; c++)
+                        out_[4 * i + c] = in[8 * i + 2 * c];  // RGB with alpha
+            else if (infoIn.bitDepth < 8 && infoIn.colorType == 0)  // greyscale
+                for (size_t i = 0; i < numpixels; i++) {
+                    unsigned long value =
+                        (readBitsFromReversedStream(bp, in, infoIn.bitDepth) *
+                         255) /
+                        ((1 << infoIn.bitDepth) -
+                         1);  // scale value from 0 to 255
+                    out_[4 * i + 0] = out_[4 * i + 1] = out_[4 * i + 2] =
+                        (unsigned char)(value);
+                    out_[4 * i + 3] =
+                        (infoIn.key_defined && value &&
+                         ((1U << infoIn.bitDepth) - 1U) == infoIn.key_r &&
+                         ((1U << infoIn.bitDepth) - 1U))
+                            ? 0
+                            : 255;
+                }
+            else if (infoIn.bitDepth < 8 && infoIn.colorType == 3)  // palette
+                for (size_t i = 0; i < numpixels; i++) {
+                    unsigned long value =
+                        readBitsFromReversedStream(bp, in, infoIn.bitDepth);
+                    if (4 * value >= infoIn.palette.size()) return 47;
+                    for (size_t c = 0; c < 4; c++)
+                        out_[4 * i + c] =
+                            infoIn.palette[4 * value + c];  // get rgb colors
+                                                            // from the palette
+                }
+            return 0;
+        }
+        unsigned char paethPredictor(
+            short a, short b,
+            short c)  // Paeth predicter, used by PNG filter type 4
+        {
+            short p = a + b - c, pa = p > a ? (p - a) : (a - p),
+                  pb = p > b ? (p - b) : (b - p),
+                  pc = p > c ? (p - c) : (c - p);
+            return (unsigned char)((pa <= pb && pa <= pc) ? a
+                                                          : pb <= pc ? b : c);
+        }
+    };
+    PNG decoder;
+    decoder.decode(out_image, in_png, in_size, convert_to_rgba32);
+    image_width = decoder.info.width;
+    image_height = decoder.info.height;
+    return decoder.error;
 }
-    
-} // yage
+
+}  // yage
diff --git a/src/rectanglecollider.cpp b/src/rectanglecollider.cpp
index 0f5ee302..e9f695d7 100644
--- a/src/rectanglecollider.cpp
+++ b/src/rectanglecollider.cpp
@@ -8,25 +8,22 @@
 
 #include "Physics/rectanglecollider.hpp"
 
-namespace yage
-{
+namespace yage {
 
-RectangleCollider::RectangleCollider(const glm::vec2 &position, const glm::vec2 &size) :
-	Collider(position, size)
-{}
+RectangleCollider::RectangleCollider(const glm::vec2& position,
+                                     const glm::vec2& size)
+    : Collider(position, size) {}
 
-bool RectangleCollider::collides(const Collider &collider) const
-{
-	for(int i=position_.x; i<position_.x+size_.x; ++i)
-		for(int j=position_.y; j<position_.y+size_.y; ++j)
-			return collider.inside(glm::vec2(i, j));
-	return false;
+bool RectangleCollider::collides(const Collider& collider) const {
+    for (int i = position_.x; i < position_.x + size_.x; ++i)
+        for (int j = position_.y; j < position_.y + size_.y; ++j)
+            return collider.inside(glm::vec2(i, j));
+    return false;
 }
 
-inline bool RectangleCollider::inside(const glm::vec2 &point) const
-{
-	return position_.x<point.x && position_.x+size_.x>point.x &&
-		position_.y<point.y && position_.y+size_.y>point.y;
+inline bool RectangleCollider::inside(const glm::vec2& point) const {
+    return position_.x < point.x && position_.x + size_.x > point.x &&
+           position_.y < point.y && position_.y + size_.y > point.y;
 }
 
-} // yage
+}  // yage
diff --git a/src/resourcemanager.cpp b/src/resourcemanager.cpp
index 8341557c..15fb606f 100644
--- a/src/resourcemanager.cpp
+++ b/src/resourcemanager.cpp
@@ -8,14 +8,12 @@
 
 #include "resourcemanager.hpp"
 
-namespace yage
-{
+namespace yage {
 
 TextureCache ResourceManager::texture_cache_;
 
-Texture ResourceManager::getTexture(const std::string &texture_path)
-{
-	return texture_cache_.getTexture(texture_path);
+Texture ResourceManager::getTexture(const std::string& texture_path) {
+    return texture_cache_.getTexture(texture_path);
 }
-    
-} // yage
+
+}  // yage
diff --git a/src/rigidbody.cpp b/src/rigidbody.cpp
index f2069c4a..f19d63ac 100644
--- a/src/rigidbody.cpp
+++ b/src/rigidbody.cpp
@@ -8,14 +8,10 @@
 
 #include "Physics/rigidbody.hpp"
 
-namespace yage
-{
+namespace yage {
 
-RigidBody::RigidBody(const Vector2d &position,
-                     double mass,
-                     const Vector2d &velocity,
-                     bool gravity) :
-	ParticleBody(position, mass, velocity, gravity)
-{}
+RigidBody::RigidBody(const Vector2d& position, double mass,
+                     const Vector2d& velocity, bool gravity)
+    : ParticleBody(position, mass, velocity, gravity) {}
 
-} // yage
+}  // yage
diff --git a/src/sprite.cpp b/src/sprite.cpp
index 2ba39e2e..e3d74982 100644
--- a/src/sprite.cpp
+++ b/src/sprite.cpp
@@ -12,79 +12,76 @@
 
 #include <cstddef>
 
-namespace yage
-{
+namespace yage {
 
-Sprite::Sprite()
-{}
+Sprite::Sprite() {}
 
-Sprite::~Sprite()
-{
-	if(vbo_id_ != 0)
-		glDeleteBuffers(1, &vbo_id_);
+Sprite::~Sprite() {
+    if (vbo_id_ != 0) glDeleteBuffers(1, &vbo_id_);
 }
 
-void Sprite::init(float x, float y, float width, float height, const std::string &texture_path)
-{
-	x_ = x;
-	y_ = y;
-	width_ = width;
-	height_ = height;
-	texture_ = ResourceManager::getTexture(texture_path);
+void Sprite::init(float x, float y, float width, float height,
+                  const std::string& texture_path) {
+    x_ = x;
+    y_ = y;
+    width_ = width;
+    height_ = height;
+    texture_ = ResourceManager::getTexture(texture_path);
 
-	if(vbo_id_ == 0)
-		glGenBuffers(1, &vbo_id_);
+    if (vbo_id_ == 0) glGenBuffers(1, &vbo_id_);
 
-	Vertex vertex_data[6];
+    Vertex vertex_data[6];
 
-	vertex_data[0].setPosition(x+width, y+height);
-	vertex_data[0].setUv(1.f, 1.f);
+    vertex_data[0].setPosition(x + width, y + height);
+    vertex_data[0].setUv(1.f, 1.f);
 
-	vertex_data[1].setPosition(x, y+height);
-	vertex_data[1].setUv(0.f, 1.f);
+    vertex_data[1].setPosition(x, y + height);
+    vertex_data[1].setUv(0.f, 1.f);
 
-	vertex_data[2].setPosition(x, y);
-	vertex_data[2].setUv(0.f, 0.f);
+    vertex_data[2].setPosition(x, y);
+    vertex_data[2].setUv(0.f, 0.f);
 
-	vertex_data[3].setPosition(x, y);
-	vertex_data[3].setUv(0.f, 0.f);
+    vertex_data[3].setPosition(x, y);
+    vertex_data[3].setUv(0.f, 0.f);
 
-	vertex_data[4].setPosition(x+width, y+height);
-	vertex_data[4].setUv(1.f, 1.f);
+    vertex_data[4].setPosition(x + width, y + height);
+    vertex_data[4].setUv(1.f, 1.f);
 
-	vertex_data[5].setPosition(x+width, y);
-	vertex_data[5].setUv(1.f, 0.f);
+    vertex_data[5].setPosition(x + width, y);
+    vertex_data[5].setUv(1.f, 0.f);
 
-	for(int i = 0; i < 6; ++i)
-		vertex_data[i].setColor(255, 0, 255, 255);
+    for (int i = 0; i < 6; ++i) vertex_data[i].setColor(255, 0, 255, 255);
 
-	vertex_data[1].setColor(0, 255, 255, 255);
-	vertex_data[4].setColor(255, 0, 0, 255);
+    vertex_data[1].setColor(0, 255, 255, 255);
+    vertex_data[4].setColor(255, 0, 0, 255);
 
-	glBindBuffer(GL_ARRAY_BUFFER, vbo_id_);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo_id_);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data,
+                 GL_STATIC_DRAW);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
-void Sprite::draw()
-{
-	glBindTexture(GL_TEXTURE_2D, texture_.id);
-	glBindBuffer(GL_ARRAY_BUFFER, vbo_id_);
-    
-	glEnableVertexAttribArray(0);
-	glEnableVertexAttribArray(1);
-	glEnableVertexAttribArray(2);
-
-	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)offsetof(Vertex, position));
-	glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex), (void *)offsetof(Vertex, color));
-	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)offsetof(Vertex, uv));
-	glDrawArrays(GL_TRIANGLES, 0, 6);
-    
-	glDisableVertexAttribArray(2);
-	glDisableVertexAttribArray(1);
-	glDisableVertexAttribArray(0);
-    
-	glBindBuffer(GL_ARRAY_BUFFER, 0);    
+void Sprite::draw() {
+    glBindTexture(GL_TEXTURE_2D, texture_.id);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo_id_);
+
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+                          (void*)offsetof(Vertex, position));
+    glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex),
+                          (void*)offsetof(Vertex, color));
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+                          (void*)offsetof(Vertex, uv));
+    glDrawArrays(GL_TRIANGLES, 0, 6);
+
+    glDisableVertexAttribArray(2);
+    glDisableVertexAttribArray(1);
+    glDisableVertexAttribArray(0);
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
-    
-} // yage
+
+}  // yage
diff --git a/src/spritebatch.cpp b/src/spritebatch.cpp
index 4018b3e2..8e64aa5e 100644
--- a/src/spritebatch.cpp
+++ b/src/spritebatch.cpp
@@ -11,168 +11,158 @@
 #include <algorithm>
 #include <stdexcept>
 
-namespace yage
-{
+namespace yage {
 
 const int SpriteBatch::NUM_VERTICES;
 
-Glyph::Glyph(GLuint texture, float depth, const Vertex &top_left, const Vertex &top_right, const Vertex &bottom_right, const Vertex &bottom_left) :
-	texture_(texture),
-	depth_(depth),
-	top_left_(top_left),
-	top_right_(top_right),
-	bottom_right_(bottom_right),
-	bottom_left_(bottom_left)
-{}
-
-RenderBatch::RenderBatch(GLint offset, GLsizei num_vertices, GLuint texture) :
-	num_vertices_(num_vertices),
-	offset_(offset),    
-	texture_(texture)
-{}
-
-SpriteBatch::SpriteBatch()
-{}
-
-SpriteBatch::~SpriteBatch()
-{
-	if(vao_!=0)
-		glDeleteVertexArrays(1, &vao_);
-
-	if(vbo_!=0)
-		glDeleteVertexArrays(1, &vbo_);
-}
+Glyph::Glyph(GLuint texture, float depth, const Vertex& top_left,
+             const Vertex& top_right, const Vertex& bottom_right,
+             const Vertex& bottom_left)
+    : texture_(texture),
+      depth_(depth),
+      top_left_(top_left),
+      top_right_(top_right),
+      bottom_right_(bottom_right),
+      bottom_left_(bottom_left) {}
+
+RenderBatch::RenderBatch(GLint offset, GLsizei num_vertices, GLuint texture)
+    : num_vertices_(num_vertices), offset_(offset), texture_(texture) {}
+
+SpriteBatch::SpriteBatch() {}
 
-void SpriteBatch::init()
-{
-	createVertexArray();
+SpriteBatch::~SpriteBatch() {
+    if (vao_ != 0) glDeleteVertexArrays(1, &vao_);
+
+    if (vbo_ != 0) glDeleteVertexArrays(1, &vbo_);
 }
 
-void SpriteBatch::begin()
-{
-	glyphs_.clear();
-	glyph_ptrs_.clear();
-	render_batches_.clear();
+void SpriteBatch::init() { createVertexArray(); }
+
+void SpriteBatch::begin() {
+    glyphs_.clear();
+    glyph_ptrs_.clear();
+    render_batches_.clear();
 }
 
-void SpriteBatch::end()
-{
-	sortGlyphs();
-	createRenderBatches();
+void SpriteBatch::end() {
+    sortGlyphs();
+    createRenderBatches();
 }
 
-void SpriteBatch::draw(const glm::vec4 &destination_rect, const glm::vec4 &uv_rect, GLuint texture, const Color &color, float depth)
-{
-	Vertex top_left, top_right, bottom_right, bottom_left;
-    
-	top_left.color=color;
-	top_left.setPosition(destination_rect.x, destination_rect.y+destination_rect.w);
-	top_left.setUv(uv_rect.x, uv_rect.y+uv_rect.w);
-
-	top_right.color=color;
-	top_right.setPosition(destination_rect.x+destination_rect.z, destination_rect.y+destination_rect.w);
-	top_right.setUv(uv_rect.x+uv_rect.z, uv_rect.y+uv_rect.w);
-
-	bottom_right.color=color;
-	bottom_right.setPosition(destination_rect.x+destination_rect.z, destination_rect.y);
-	bottom_right.setUv(uv_rect.x+uv_rect.z, uv_rect.y);
-
-	bottom_left.color=color;
-	bottom_left.setPosition(destination_rect.x, destination_rect.y);
-	bottom_left.setUv(uv_rect.x, uv_rect.y);
-    
-	// deal with fragmenting by creating vector of pointers
-	glyphs_.emplace_back(texture, depth, top_left, top_right, bottom_right, bottom_left);
-	glyph_ptrs_.push_back(&glyphs_.back());
+void SpriteBatch::draw(const glm::vec4& destination_rect,
+                       const glm::vec4& uv_rect, GLuint texture,
+                       const Color& color, float depth) {
+    Vertex top_left, top_right, bottom_right, bottom_left;
+
+    top_left.color = color;
+    top_left.setPosition(destination_rect.x,
+                         destination_rect.y + destination_rect.w);
+    top_left.setUv(uv_rect.x, uv_rect.y + uv_rect.w);
+
+    top_right.color = color;
+    top_right.setPosition(destination_rect.x + destination_rect.z,
+                          destination_rect.y + destination_rect.w);
+    top_right.setUv(uv_rect.x + uv_rect.z, uv_rect.y + uv_rect.w);
+
+    bottom_right.color = color;
+    bottom_right.setPosition(destination_rect.x + destination_rect.z,
+                             destination_rect.y);
+    bottom_right.setUv(uv_rect.x + uv_rect.z, uv_rect.y);
+
+    bottom_left.color = color;
+    bottom_left.setPosition(destination_rect.x, destination_rect.y);
+    bottom_left.setUv(uv_rect.x, uv_rect.y);
+
+    // deal with fragmenting by creating vector of pointers
+    glyphs_.emplace_back(texture, depth, top_left, top_right, bottom_right,
+                         bottom_left);
+    glyph_ptrs_.push_back(&glyphs_.back());
 }
 
-void SpriteBatch::render()
-{
-	glBindVertexArray(vao_);
-	for(auto &&batch : render_batches_)
-	{
-		glBindTexture(GL_TEXTURE_2D, batch.texture());
-		glDrawArrays(GL_TRIANGLES, batch.offset(), batch.num_vertices());
-	}
-	glBindVertexArray(0);
+void SpriteBatch::render() {
+    glBindVertexArray(vao_);
+    for (auto&& batch : render_batches_) {
+        glBindTexture(GL_TEXTURE_2D, batch.texture());
+        glDrawArrays(GL_TRIANGLES, batch.offset(), batch.num_vertices());
+    }
+    glBindVertexArray(0);
 }
 
-void SpriteBatch::createVertexArray()
-{
-	if(vao_==0)
-	{
-		glGenVertexArrays(1, &vao_);
-		if(vao_==0)
-			throw std::runtime_error("glGenVertexArrays failed");
-	}
-	// bind vertex array object
-	glBindVertexArray(vao_);
-    
-	if(vbo_==0)
-	{
-		glGenBuffers(1, &vbo_);
-		if(vbo_==0)
-			throw std::runtime_error("glGenBuffers failed");
-	}
-	// bind vertex buffer object
-	glBindBuffer(GL_ARRAY_BUFFER, vbo_);
-
-	// enable vertex attribute arrays
-	glEnableVertexAttribArray(0);
-	glEnableVertexAttribArray(1);
-	glEnableVertexAttribArray(2);
-
-	// set the vertex attribute pointers
-	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)offsetof(Vertex, position));
-	glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex), (void *)offsetof(Vertex, color));
-	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)offsetof(Vertex, uv));
-	glDrawArrays(GL_TRIANGLES, 0, 6);
-
-	// unbind vertex array object
-	glBindVertexArray(0);
+void SpriteBatch::createVertexArray() {
+    if (vao_ == 0) {
+        glGenVertexArrays(1, &vao_);
+        if (vao_ == 0) throw std::runtime_error("glGenVertexArrays failed");
+    }
+    // bind vertex array object
+    glBindVertexArray(vao_);
+
+    if (vbo_ == 0) {
+        glGenBuffers(1, &vbo_);
+        if (vbo_ == 0) throw std::runtime_error("glGenBuffers failed");
+    }
+    // bind vertex buffer object
+    glBindBuffer(GL_ARRAY_BUFFER, vbo_);
+
+    // enable vertex attribute arrays
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+
+    // set the vertex attribute pointers
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+                          (void*)offsetof(Vertex, position));
+    glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex),
+                          (void*)offsetof(Vertex, color));
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+                          (void*)offsetof(Vertex, uv));
+    glDrawArrays(GL_TRIANGLES, 0, 6);
+
+    // unbind vertex array object
+    glBindVertexArray(0);
 }
 
-void SpriteBatch::createRenderBatches()
-{
-	std::vector<Vertex> vertices;
-	if(glyph_ptrs_.empty())
-		return;
-    
-	render_batches_.reserve(glyph_ptrs_.size()*NUM_VERTICES);
-
-	for(int i=0; i<(int)glyph_ptrs_.size(); ++i)
-	{
-		if(i==0 || (i>0 && (glyph_ptrs_[i]->texture()!=glyph_ptrs_[i-1]->texture())))
-			render_batches_.emplace_back(i*NUM_VERTICES, NUM_VERTICES, glyph_ptrs_[i]->texture());
-		else
-			render_batches_.back().num_vertices_+=NUM_VERTICES;
-
-		vertices.push_back(glyph_ptrs_[i]->bottom_left());
-		vertices.push_back(glyph_ptrs_[i]->top_left());
-		vertices.push_back(glyph_ptrs_[i]->top_right());
-		vertices.push_back(glyph_ptrs_[i]->bottom_left());
-		vertices.push_back(glyph_ptrs_[i]->bottom_right());
-		vertices.push_back(glyph_ptrs_[i]->top_right());
-
-		// bind vbo
-		glBindBuffer(GL_ARRAY_BUFFER, vbo_);
-		// orphan the buffer
-		glBufferData(GL_ARRAY_BUFFER, vertices.size()*sizeof(Vertex), nullptr, GL_DYNAMIC_DRAW);
-		// upload the data
-		glBufferSubData(GL_ARRAY_BUFFER, 0, vertices.size()*sizeof(Vertex), vertices.data());
-		// unbind buffer
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-	}
+void SpriteBatch::createRenderBatches() {
+    std::vector<Vertex> vertices;
+    if (glyph_ptrs_.empty()) return;
+
+    render_batches_.reserve(glyph_ptrs_.size() * NUM_VERTICES);
+
+    for (int i = 0; i < (int)glyph_ptrs_.size(); ++i) {
+        if (i == 0 || (i > 0 && (glyph_ptrs_[i]->texture() !=
+                                 glyph_ptrs_[i - 1]->texture())))
+            render_batches_.emplace_back(i * NUM_VERTICES, NUM_VERTICES,
+                                         glyph_ptrs_[i]->texture());
+        else
+            render_batches_.back().num_vertices_ += NUM_VERTICES;
+
+        vertices.push_back(glyph_ptrs_[i]->bottom_left());
+        vertices.push_back(glyph_ptrs_[i]->top_left());
+        vertices.push_back(glyph_ptrs_[i]->top_right());
+        vertices.push_back(glyph_ptrs_[i]->bottom_left());
+        vertices.push_back(glyph_ptrs_[i]->bottom_right());
+        vertices.push_back(glyph_ptrs_[i]->top_right());
+
+        // bind vbo
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_);
+        // orphan the buffer
+        glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), nullptr,
+                     GL_DYNAMIC_DRAW);
+        // upload the data
+        glBufferSubData(GL_ARRAY_BUFFER, 0, vertices.size() * sizeof(Vertex),
+                        vertices.data());
+        // unbind buffer
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+    }
 }
 
-void SpriteBatch::sortGlyphs()
-{
-	// sort using introsort or quicksort
-	std::sort(glyph_ptrs_.begin(), glyph_ptrs_.end(), [] (Glyph *a, Glyph *b)->bool {
-			if(a->depth()==b->depth())
-				return a->texture()<b->texture();
-			return a->depth()<b->depth();
-		});
+void SpriteBatch::sortGlyphs() {
+    // sort using introsort or quicksort
+    std::sort(glyph_ptrs_.begin(), glyph_ptrs_.end(),
+              [](Glyph* a, Glyph* b) -> bool {
+                  if (a->depth() == b->depth())
+                      return a->texture() < b->texture();
+                  return a->depth() < b->depth();
+              });
 }
 
-} // yage
+}  // yage
diff --git a/src/window.cpp b/src/window.cpp
index 60cdb4ef..7a00b0c9 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -13,77 +13,68 @@
 #include <iostream>
 #include <stdexcept>
 
-namespace yage
-{
-
-Window::Window()
-{}
-
-Window::~Window()
-{
-	SDL_DestroyWindow(window_);
+namespace yage {
+
+Window::Window() {}
+
+Window::~Window() { SDL_DestroyWindow(window_); }
+
+void Window::create(const std::string& window_name, int width, int height,
+                    unsigned flags) {
+    Uint32 gl_window_states = 0;
+
+    // set the correct input flags
+    if (flags & WindowFlags::SHOWN) gl_window_states |= SDL_WINDOW_OPENGL;
+    if (flags & WindowFlags::HIDDEN) gl_window_states |= SDL_WINDOW_HIDDEN;
+    if (flags & WindowFlags::FULLSCREEN)
+        gl_window_states |= SDL_WINDOW_FULLSCREEN;
+    if (flags & WindowFlags::BORDERLESS)
+        gl_window_states |= SDL_WINDOW_BORDERLESS;
+
+    // SDL_GL options
+
+    // SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+    // SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 5);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+    // create the SDL window
+    window_ = SDL_CreateWindow(window_name.c_str(), SDL_WINDOWPOS_CENTERED,
+                               SDL_WINDOWPOS_CENTERED, width, height,
+                               gl_window_states);
+    if (window_ == nullptr) throw std::runtime_error("SDL_CreateWindow failed");
+
+    // initialize the GL context in the window
+    SDL_GLContext gl_context = SDL_GL_CreateContext(window_);
+    if (gl_context == nullptr)
+        throw std::runtime_error("SDL_GL_CreateContext failed");
+
+    // initialize glew
+    GLenum error = glewInit();
+    if (error != GLEW_OK) throw std::runtime_error("glewInit failed");
+
+    // print out the current OpenGL version to debug
+    std::cout << "***  OpenGL version: " << glGetString(GL_VERSION)
+              << "  ***\n";
+
+    // set vsync on instead of custom fps limiting
+    SDL_GL_SetSwapInterval(1);
+    // set the clear color to black
+    glClearColor(0.f, 0.5f, 0.f, 1.f);
+    // set alpha blending
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
-void Window::create(const std::string &window_name, int width, int height, unsigned flags)
-{
-	Uint32 gl_window_states=0;
-
-	// set the correct input flags
-	if(flags & WindowFlags::SHOWN)
-		gl_window_states|=SDL_WINDOW_OPENGL;
-	if(flags & WindowFlags::HIDDEN)
-		gl_window_states|=SDL_WINDOW_HIDDEN;
-	if(flags & WindowFlags::FULLSCREEN)
-		gl_window_states|=SDL_WINDOW_FULLSCREEN;
-	if(flags & WindowFlags::BORDERLESS)
-		gl_window_states|=SDL_WINDOW_BORDERLESS;
-
-	// SDL_GL options
-    
-	// SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-	// SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 5);
-	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-
-	// create the SDL window
-	window_ = SDL_CreateWindow(window_name.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
-	                           width, height, gl_window_states);
-	if(window_ == nullptr)
-		throw std::runtime_error("SDL_CreateWindow failed");
-
-	// initialize the GL context in the window
-	SDL_GLContext gl_context = SDL_GL_CreateContext(window_);
-	if(gl_context == nullptr)
-		throw std::runtime_error("SDL_GL_CreateContext failed");
-
-	// initialize glew
-	GLenum error = glewInit();
-	if(error != GLEW_OK)
-		throw std::runtime_error("glewInit failed");
-
-	// print out the current OpenGL version to debug
-	std::cout<<"***  OpenGL version: "<<glGetString(GL_VERSION)<<"  ***\n";
-
-	// set vsync on instead of custom fps limiting
-	SDL_GL_SetSwapInterval(1);
-	// set the clear color to black
-	glClearColor(0.f, 0.5f, 0.f, 1.f);
-	// set alpha blending
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+void Window::swapBuffer() {
+    // swap the window buffer
+    SDL_GL_SwapWindow(window_);
 }
 
-void Window::swapBuffer()
-{
-	// swap the window buffer
-	SDL_GL_SwapWindow(window_);
+void Window::clearBuffer() {
+    // set the clear depth
+    glClearDepth(1.f);
+    // clears buffer with clear color
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }
 
-void Window::clearBuffer()
-{
-	// set the clear depth
-	glClearDepth(1.f);
-	// clears buffer with clear color
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-}
-    
-} // yage
+}  // yage