Linting pass

doc/coding_standard.txt

@@ -31,6 +31,9 @@ must do's:
 		comments max 2 lines
 		no void in parameter list: void func(){}
 	brace formatting:
+		namespace thing{
+
+		}
 		void function(void){
 
 		}
@@ -91,5 +94,5 @@ no-no's:
 		struct game_state* gl; //bad boi
 	excess include directives
 	if body on the same line as the if keyword
-	elso body on the same line as the else keyword
+	else body on the same line as the else keyword
 		if(thing) do_stuff();

include/math/detail/matrix.tpp

@@ -40,11 +40,11 @@ namespace math::detail{
 	constexpr T determinate_helper<T,R>::perform(const matrix<T,R,R>& m){
 		T sum = 0;
 		T op = 1;
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			T item = op * m[0][i];
 			matrix<T,R-1,R-1> mul(no_initialize);
-			for(size_t j = 1, mj = 0;j < R;++j){
+			for(size_t j = 1, mj = 0; j < R; ++j){
-				for(size_t k = 0, mk = 0;k < R;++k){
+				for(size_t k = 0, mk = 0; k < R; ++k){
 					if(k == i)
 						continue;
 					mul[mj][mk] = m[j][k];
@@ -92,70 +92,55 @@ namespace math::detail{
 	}
 	template<typename T>
 	constexpr matrix<T,4,4> inverse_helper<T,4>::perform(const matrix<T,4,4>& m){
+		//barely over 50 lines, can be made slightly shorter by making the return statement unreadable
 		T det = m.determinate();
 		if(!det)
 			return matrix<T,4,4>(zero_initialize);
-		//Math is power
 		return matrix<T,4,4>((m.get(5) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14)))  -
 		                      m.get(6) * ((m.get(9)  * m.get(15)) - (m.get(11) * m.get(13)))  +
 		                      m.get(7) * ((m.get(9)  * m.get(14)) - (m.get(10) * m.get(13)))) / det,
-
 		                    -(m.get(1) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14)))  -
 		                      m.get(2) * ((m.get(9)  * m.get(15)) - (m.get(11) * m.get(13)))  +
 		                      m.get(3) * ((m.get(9)  * m.get(14)) - (m.get(10) * m.get(13)))) / det,
-
 		                     (m.get(1) * ((m.get(6)  * m.get(15)) - (m.get(7)  * m.get(14)))  -
 		                      m.get(2) * ((m.get(5)  * m.get(15)) - (m.get(7)  * m.get(13)))  +
 		                      m.get(3) * ((m.get(5)  * m.get(14)) - (m.get(6)  * m.get(13)))) / det,
-
 		                    -(m.get(1) * ((m.get(6)  * m.get(11)) - (m.get(7)  * m.get(10)))  -
 		                      m.get(2) * ((m.get(5)  * m.get(11)) - (m.get(7)  * m.get(9)))   +
 		                      m.get(3) * ((m.get(5)  * m.get(10)) - (m.get(6)  * m.get(9))))  / det,
-
 		                    -(m.get(4) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14)))  -
 		                      m.get(6) * ((m.get(8)  * m.get(15)) - (m.get(11) * m.get(12)))  +
 		                      m.get(7) * ((m.get(8)  * m.get(14)) - (m.get(10) * m.get(12)))) / det,
-
 		                     (m.get(0) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14)))  -
 		                      m.get(2) * ((m.get(8)  * m.get(15)) - (m.get(11) * m.get(12)))  +
 		                      m.get(3) * ((m.get(8)  * m.get(14)) - (m.get(10) * m.get(12)))) / det,
-
 		                    -(m.get(0) * ((m.get(6)  * m.get(15)) - (m.get(7)  * m.get(14)))  -
 		                      m.get(2) * ((m.get(4)  * m.get(15)) - (m.get(7)  * m.get(12)))  +
 		                      m.get(3) * ((m.get(4)  * m.get(14)) - (m.get(6)  * m.get(12)))) / det,
-
 		                     (m.get(0) * ((m.get(6)  * m.get(11)) - (m.get(7)  * m.get(10)))  -
 		                      m.get(2) * ((m.get(4)  * m.get(11)) - (m.get(7)  * m.get(8)))   +
 		                      m.get(3) * ((m.get(4)  * m.get(10)) - (m.get(6)  * m.get(8))))  / det,
-
 		                     (m.get(4) * ((m.get(9)  * m.get(15)) - (m.get(11) * m.get(13)))  -
 		                      m.get(5) * ((m.get(8)  * m.get(15)) - (m.get(11) * m.get(12)))  +
 		                      m.get(7) * ((m.get(8)  * m.get(13)) - (m.get(9)  * m.get(12)))) / det,
-
 		                    -(m.get(0) * ((m.get(9)  * m.get(15)) - (m.get(11) * m.get(13)))  -
 		                      m.get(1) * ((m.get(8)  * m.get(15)) - (m.get(11) * m.get(12)))  +
 		                      m.get(3) * ((m.get(8)  * m.get(13)) - (m.get(9)  * m.get(12)))) / det,
-
 		                     (m.get(0) * ((m.get(5)  * m.get(15)) - (m.get(7)  * m.get(13)))  -
 		                      m.get(1) * ((m.get(4)  * m.get(15)) - (m.get(7)  * m.get(12)))  +
 		                      m.get(3) * ((m.get(4)  * m.get(13)) - (m.get(5)  * m.get(12)))) / det,
-
 		                    -(m.get(0) * ((m.get(5)  * m.get(11)) - (m.get(7)  * m.get(9)))   -
 		                      m.get(1) * ((m.get(4)  * m.get(11)) - (m.get(7)  * m.get(8)))   +
 		                      m.get(3) * ((m.get(4)  * m.get(9))  - (m.get(5)  * m.get(8))))  / det,
-
 		                    -(m.get(4) * ((m.get(9)  * m.get(14)) - (m.get(10) * m.get(13)))  -
 		                      m.get(5) * ((m.get(8)  * m.get(14)) - (m.get(10) * m.get(12)))  +
 		                      m.get(6) * ((m.get(8)  * m.get(13)) - (m.get(9)  * m.get(12)))) / det,
-
 		                     (m.get(0) * ((m.get(9)  * m.get(14)) - (m.get(10) * m.get(13)))  -
 		                      m.get(1) * ((m.get(8)  * m.get(14)) - (m.get(10) * m.get(12)))  +
 		                      m.get(2) * ((m.get(8)  * m.get(13)) - (m.get(9)  * m.get(12)))) / det,
-
 		                    -(m.get(0) * ((m.get(5)  * m.get(14)) - (m.get(6)  * m.get(13)))  -
 		                      m.get(1) * ((m.get(4)  * m.get(14)) - (m.get(6)  * m.get(12)))  +
 		                      m.get(2) * ((m.get(4)  * m.get(13)) - (m.get(5)  * m.get(12)))) / det,
-
 		                     (m.get(0) * ((m.get(5)  * m.get(10)) - (m.get(6)  * m.get(9)))   -
 		                      m.get(1) * ((m.get(4)  * m.get(10)) - (m.get(6)  * m.get(8)))   +
 		                      m.get(2) * ((m.get(4)  * m.get(9))  - (m.get(5)  * m.get(8))))  / det);

include/math/mat.hpp

@@ -90,7 +90,6 @@ namespace math{
 		constexpr const_pointer raw()const;
 		constexpr operator pointer();
 		constexpr operator const_pointer()const;
-
 	};
 
 	template<typename T, size_t R, size_t C>

include/math/mat.tpp

@@ -44,7 +44,7 @@ namespace math{
 
 	template<typename T, size_t R, size_t C>
 	constexpr matrix_base<T,R,C>::matrix_base(value_type v){
-		for(size_type i = 0;i < Columns*Rows;++i)
+		for(size_type i = 0; i < Columns*Rows; ++i)
 			m_data[i] = v;
 	}
 	template<typename T, size_t R, size_t C>
@@ -56,7 +56,7 @@ namespace math{
 	template<typename U>
 	constexpr matrix_base<T,R,C>::matrix_base(const matrix_base<U,Columns,Rows>& m){
 		using mat = decltype(m);
-		for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
+		for(typename mat::size_type i = 0; i < mat::Columns*mat::Rows; ++i)
 			m_data[i] = m.get(i);
 	}
 
@@ -64,7 +64,7 @@ namespace math{
 	template<typename U>
 	constexpr matrix_base<T,R,C>& matrix_base<T,R,C>::operator=(const matrix_base<U,Columns,Rows>& m){
 		using mat = decltype(m);
-		for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
+		for(typename mat::size_type i = 0; i < mat::Columns*mat::Rows; ++i)
 			m_data[i] = m.get(i);
 		return *this;
 	}
@@ -149,15 +149,15 @@ namespace math{
 	template<typename T, size_t R>
 	constexpr auto matrix<T,R,R>::trace()const -> value_type{
 		value_type sum = 0;
-		for(size_type i = 0;i < R;++i){
+		for(size_type i = 0; i < R; ++i){
 			sum += get(i, i);
 		}
 	}
 	template<typename T, size_t R>
 	constexpr matrix<T,R,R> matrix<T,R,R>::transpose()const{
 		matrix m(no_initialize);
-		for(size_type i = 0;i < R;++i){
+		for(size_type i = 0; i < R; ++i){
-			for(size_type j = 0;j < R;++j){
+			for(size_type j = 0; j < R; ++j){
 				m.get(j, i) = get(i, j);
 			}
 		}
@@ -264,7 +264,7 @@ namespace math{
 
 	template<typename T, typename U, size_t R, size_t C>
 	constexpr bool operator==(const matrix_base<T,R,C>& left, const matrix_base<U,R,C> right){
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			if(left.get(i) != right.get(i))
 				return false;
 		}
@@ -280,9 +280,9 @@ namespace math{
 		using res_t = decltype(std::declval<T>() * std::declval<U>());
 		matrix<res_t,R1,C2> res(zero_initialize);
 		size_t index = 0;
-		for(size_t i = 0;i < left.rows();++i){
+		for(size_t i = 0; i < left.rows(); ++i){
-			for(size_t j = 0;j < right.columns();++j){
+			for(size_t j = 0; j < right.columns(); ++j){
-				for(size_t k = 0;k < right.rows();++k){
+				for(size_t k = 0; k < right.rows(); ++k){
 					res.get(index) += left[i][k] * right[k][j];
 				}
 				++index;
@@ -293,7 +293,7 @@ namespace math{
 	constexpr auto operator*(const matrix<T,R,C>& left, U&& right){
 		using res_t = decltype(std::declval<T>() * std::declval<U>());
 		matrix<res_t,R,C> res(no_initialize);
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			res.get(i) = left.get(i) * std::forward<U>(right);
 		}
 		return res;
@@ -302,7 +302,7 @@ namespace math{
 	constexpr auto operator*(U&& left, const matrix<T,R,C>& right){
 		using res_t = decltype(std::declval<T>() * std::declval<U>());
 		matrix<res_t,R,C> res(no_initialize);
-		for(size_t i = 0;i < right.size();++i){
+		for(size_t i = 0; i < right.size(); ++i){
 			res.get(i) = std::forward<U>(left) * right.get(i);
 		}
 		return res;
@@ -311,7 +311,7 @@ namespace math{
 	constexpr auto operator/(const matrix<T,R,C>& left, U&& right){
 		using res_t = decltype(std::declval<T>() / std::declval<U>());
 		matrix<res_t,R,C> res(no_initialize);
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			res.get(i) = left.get(i) / std::forward<U>(right);
 		}
 		return res;
@@ -320,7 +320,7 @@ namespace math{
 	constexpr auto operator+(const matrix<T,R,C>& left, const matrix<U,R,C>& right){
 		using res_t = decltype(std::declval<T>() + std::declval<U>());
 		matrix<res_t,R,C> res(no_initialize);
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			res.get(i) = left.get(i) + right.get(i);
 		}
 		return res;
@@ -329,7 +329,7 @@ namespace math{
 	constexpr auto operator-(const matrix<T,R,C>& left, const matrix<U,R,C>& right){
 		using res_t = decltype(std::declval<T>() - std::declval<U>());
 		matrix<res_t,R,C> res(no_initialize);
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			res.get(i) = left.get(i) - right.get(i);
 		}
 		return res;
@@ -338,7 +338,7 @@ namespace math{
 	constexpr auto operator-(const matrix<T,R,C>& left){
 		using res_t = decltype(-std::declval<U>());
 		matrix<res_t,R,C> res(no_initialize);
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			res.get(i) = -left.get(i);
 		}
 		return res;
@@ -353,28 +353,28 @@ namespace math{
 	}
 	template<typename T, typename U, size_t C, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
 	constexpr decltype(auto) operator*=(matrix<T,R,C>& left, U&& right){
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			left.get(i) = left.get(i) * std::forward<U>(right);
 		}
 		return left;
 	}
 	template<typename T, typename U, size_t C, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
 	constexpr decltype(auto) operator/=(matrix<T,R,C>& left, U&& right){
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			left.get(i) = left.get(i) / std::forward<U>(right);
 		}
 		return left;
 	}
 	template<typename T, typename U, size_t C, size_t R>
 	constexpr decltype(auto) operator+=(matrix<T,R,C>& left, const matrix<U,R,C>& right){
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			left.get(i) = left.get(i) + right.get(i);
 		}
 		return left;
 	}
 	template<typename T, typename U, size_t C, size_t R>
 	constexpr decltype(auto) operator-=(matrix<T,R,C>& left, const matrix<U,R,C>& right){
-		for(size_t i = 0;i < left.size();++i){
+		for(size_t i = 0; i < left.size(); ++i){
 			left.get(i) = left.get(i) - right.get(i);
 		}
 		return left;

include/math/math_common.hpp

@@ -22,10 +22,10 @@
 namespace math{
 
 	namespace detail{
-		struct zero_initialize_t{};
+		struct zero_initialize_t {};
-		struct no_initialize_t{};
+		struct no_initialize_t {};
-		struct id_initialize_t{};
+		struct id_initialize_t {};
-		struct manual_initialize_t{};
+		struct manual_initialize_t {};
 	}
 
 	static inline constexpr detail::zero_initialize_t zero_initialize;

include/math/vec.tpp

@@ -87,8 +87,8 @@ namespace math{
 		vector<res_t,R> res(zero_initialize);
 		size_t index = 0;
 		//columns == rows
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
-			for(size_t k = 0;k < C;++k){
+			for(size_t k = 0; k < C; ++k){
 				res.get(index) += left[i][k] * right[k];
 			}
 			++index;
@@ -99,7 +99,7 @@ namespace math{
 	constexpr auto operator*(const vector<T,R>& left, const vector<U,R>& right){
 		using res_t = decltype(std::declval<T>() * std::declval<U>());
 		res_t res = 0;
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			res += left[i] * right[i];
 		}
 		return res;
@@ -108,7 +108,7 @@ namespace math{
 	constexpr auto operator*(const vector<T,R>& left, U&& right){
 		using res_t = decltype(std::declval<T>() * std::declval<U>());
 		vector<res_t,R> res(zero_initialize);
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			res[i] = left[i] * std::forward<U>(right);
 		}
 		return res;
@@ -117,7 +117,7 @@ namespace math{
 	constexpr auto operator*(U&& left, const vector<T,R>& right){
 		using res_t = decltype(std::declval<U>() * std::declval<T>());
 		vector<res_t,R> res(zero_initialize);
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			res[i] = std::forward<U>(right) * left[i];
 		}
 		return res;
@@ -126,7 +126,7 @@ namespace math{
 	constexpr auto operator/(const vector<T,R>& left, U&& right){
 		using res_t = decltype(std::declval<T>() / std::declval<U>());
 		vector<res_t,R> res(zero_initialize);
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			res[i] = left[i] / std::forward<U>(right);
 		}
 		return res;
@@ -135,7 +135,7 @@ namespace math{
 	constexpr auto operator+(const vector<T,R>& left, const vector<U,R>& right){
 		using res_t = decltype(std::declval<T>() + std::declval<U>());
 		vector<res_t,R> res(zero_initialize);
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			res[i] = left[i] + right[i];
 		}
 		return res;
@@ -144,7 +144,7 @@ namespace math{
 	constexpr auto operator-(const vector<T,R>& left, const vector<U,R>& right){
 		using res_t = decltype(std::declval<T>() - std::declval<U>());
 		vector<res_t,R> res(zero_initialize);
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			res[i] = left[i] - right[i];
 		}
 		return res;
@@ -153,7 +153,7 @@ namespace math{
 	constexpr auto operator-(const vector<T,R>& left){
 		using res_t = decltype(-std::declval<U>());
 		vector<res_t,R> res(zero_initialize);
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			res[i] = -left[i];
 		}
 		return res;
@@ -161,28 +161,28 @@ namespace math{
 
 	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
 	constexpr decltype(auto) operator*=(vector<T,R>& left, U&& right){
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			left[i] *= right;
 		}
 		return left;
 	}
 	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
 	constexpr decltype(auto) operator/=(vector<T,R>& left, U&& right){
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			left[i] /= right;
 		}
 		return left;
 	}
 	template<typename T, typename U, size_t R>
 	constexpr decltype(auto) operator+=(vector<T,R>& left, const vector<U,R>& right){
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			left[i] += right[i];
 		}
 		return left;
 	}
 	template<typename T, typename U, size_t R>
 	constexpr decltype(auto) operator-=(vector<T,R>& left, const vector<U,R>& right){
-		for(size_t i = 0;i < R;++i){
+		for(size_t i = 0; i < R; ++i){
 			left[i] -= right[i];
 		}
 		return left;

include/render.hpp

@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include <GLFW/glfw3.h>
 
-#define OPENFL_VERSION 400
+#define OPENGL_VERSION 400
 #define GLSL_VERSION 400
 
 class GLFWwindow;
@@ -19,18 +19,18 @@ private:
 	GLFWwindow* m_main_window;
 
 public:
-	enum RENDERER_ERROR{
+	enum renderer_error{
 		RENDERER_OK,
 		RENDERER_CONTEXT_ERROR,
 		RENDERER_WINDOW_ERROR,
 		RENDERER_INIT_ERROR,
 	};
 
-	render_manager (const render_manager&) = delete;
+	render_manager(const render_manager&) = delete;
-	render_manager (render_manager&&) = delete;
+	render_manager(render_manager&&) = delete;
 
 	render_manager();
-	RENDERER_ERROR init(int width, int height, const char* title); // Sets up the OpenGL environment
+	renderer_error init(int width, int height, const char* title); // Sets up the OpenGL environment
 	void update(); // Update the GL context and draw new frame
 	void request_exit();
 

src/main.cpp

@@ -14,25 +14,24 @@
 
 #define TILE_COUNT 9
 
-namespace
+namespace{
-{
 	bool running = true;
 	render_manager manager;
 }
 
 int get_player_input(){
 	//TODO get player input
-	return rand()%9;
+	return rand() % 9;
 }
 
 int check_win_condition(const game_state& gs, char player){
 	int i;
-	for( i = 0 ; i < 3 ; i++){
+	for(i = 0 ; i < 3; i++){
 		//rows
-		if(gs.board[(i*3)]==player && gs.board[(i*3)+1]==player && gs.board[(i*3)+2]==player)
+		if(gs.board[(i*3)] == player && gs.board[(i*3)+1] == player && gs.board[(i*3)+2] == player)
 			return 1;
 		//column
-		if(gs.board[i]==player && gs.board[i+3]==player && gs.board[i+6]==player)
+		if(gs.board[i] == player && gs.board[i+3] == player && gs.board[i+6] == player)
 			return 1;
 	}
 	if(gs.board[0] == player && gs.board[4] == player && gs.board[8] == player)
@@ -46,7 +45,7 @@ int check_win_condition(const game_state& gs, char player){
 void display_game_state(const game_state& gs){
 	printf("turn %i:\n", gs.turn);
 	for(int i = 0; i < 3; i++){
-		for(int j = 0; j < 3 ; j++){
+		for(int j = 0; j < 3; j++){
 			if(gs.board[(i*3)+j])
 				printf("%c", gs.board[(i*3)+j]);
 			else
@@ -73,13 +72,13 @@ void game_turn(game_state& gs,int player_input){
 	display_game_state(gs);
 	if(gs.turn == -1)
 		return;
-	player_turn(gs, 'X', rand()%TILE_COUNT);
+	player_turn(gs, 'X', rand() % TILE_COUNT);
 	display_game_state(gs);
 }
 
 int exists_empty_tile(const game_state& gs){
 	int i;
-	for( i = 0; i < TILE_COUNT ; i++)
+	for(i = 0; i < TILE_COUNT; i++)
 		if(!gs.board[i])
 			return 1;
 	return 0;
@@ -90,15 +89,14 @@ void play_audio(){
 }
 
 void handle_window_close(){
-	printf ("[II] Window close event triggered\n");
+	printf("[II] Window close event triggered\n");
 	running = false;
 }
 
-void handle_input_events(GLFWwindow*, int key, int, int, int)
+void handle_input_events(GLFWwindow*, int key, int, int, int){
-{
+	printf("[II] Recieved keycode %d\n", key);
-	printf ("[II] Recieved keycode %d\n", key);
+	if(key == 256)
-	if (key == 256)
+		manager.request_exit();
-		manager.request_exit ();
 }
 
 int main(){
@@ -108,9 +106,9 @@ int main(){
 	play_audio();
 	manager.init(640, 480, "Tic-Tac-Gugh");
 	manager.handle_window_close_event(handle_window_close);
-	manager.handle_keypress_event (handle_input_events);
+	manager.handle_keypress_event(handle_input_events);
 
-	while (running)
+	while(running)
 		manager.update();
 
 	while(exists_empty_tile(gs) && gs.turn != -1){

src/render.cpp

@@ -1,9 +1,8 @@
 #include <gl3w/GL/gl3w.h> // Must be included first
 #include "render.hpp"
-#include <stdio.h>
+#include <cstdio>
 
-namespace
+namespace{
-{
 	void handle_resize_event(GLFWwindow*, int width, int height){
 		printf("Window resized\n");
 		glViewport(0, 0, width, height);
@@ -12,12 +11,12 @@ namespace
 
 
 render_manager::render_manager() :
-	m_window_close_callback (nullptr),
+	m_window_close_callback(nullptr),
-	m_input_handler (nullptr),
+	m_input_handler(nullptr),
-	m_main_window (nullptr){}
+	m_main_window(nullptr){}
 
-render_manager::RENDERER_ERROR render_manager::init (int width, int height, const char* title){
+render_manager::renderer_error render_manager::init (int width, int height, const char* title){
-	if (!glfwInit()) {
+	if(!glfwInit()){
 		fprintf(stderr, "[EE] failed to initialize GLFW.\n");
 		return RENDERER_INIT_ERROR;
 	}
@@ -27,13 +26,13 @@ render_manager::RENDERER_ERROR render_manager::init (int width, int height, cons
 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 
 	m_main_window = glfwCreateWindow(width, height, title, nullptr, nullptr);
-	if (!m_main_window) {
+	if(!m_main_window){
-		fprintf (stderr, "[EE] Could not create window\n");
+		fprintf(stderr, "[EE] Could not create window\n");
 		return RENDERER_WINDOW_ERROR;
 	}
 
 	glfwMakeContextCurrent(m_main_window);
-	if (gl3wInit()) {
+	if(gl3wInit()){
 		fprintf(stderr, "[EE] failed to initialize OpenGL\n");
 		return RENDERER_CONTEXT_ERROR;
 	}
@@ -52,9 +51,8 @@ void render_manager::update(){
 	glfwPollEvents();
 }
 
-void render_manager::request_exit()
+void render_manager::request_exit(){
-{
 	if (m_window_close_callback)
 		m_window_close_callback();
-	glfwSetWindowShouldClose(m_main_window, true);
+	glfwSetWindowShouldClose(m_main_window, GLFW_TRUE);
 }