diff --git a/include/engine/base_types.hpp b/include/engine/base_types.hpp
index 14204a2..6b713c8 100644
--- a/include/engine/base_types.hpp
+++ b/include/engine/base_types.hpp
@@ -20,86 +20,55 @@
 #define OUR_DICK_ENGINE_BASE_TYPES_HPP
 
 #include "math/vec.hpp"
-#include "collision.hpp"
 
 namespace egn{
 
-	class basic_point : public math::vec3<float>
+	class point : public math::vec3<float>
 	{
 	public:
 		using math::vec3<float>::vec3;
-		using math::vec3<float>::operator=;
 	};
-	class point : public basic_point, public collidable<point>
+	class line
 	{
 	public:
-		using basic_point::basic_point;
-		using basic_point::operator=;
+		point point1;
+		point point2;
 	};
-
-	class basic_line
+	class plane
 	{
 	public:
-		math::vec3<float> point1;
-		math::vec3<float> point2;
+		point point1;
+		point point2;
+		point point3;
 	};
-	class line : public basic_line, public collidable<line>{};
-
-	class basic_plane
+	class aabb
 	{
 	public:
-		math::vec3<float> point1;
-		math::vec3<float> point2;
-		math::vec3<float> point3;
+		point point1 = {};
+		point point2 = {};
+	public:
+		aabb() = default;
+		aabb(const math::vec3<float>& p1, const math::vec3<float>& p2);
+		aabb(const aabb&) = default;
+		aabb(aabb&&) = default;
+		~aabb() = default;
+		aabb& operator=(const aabb&) = default;
+		aabb& operator=(aabb&&) = default;
 	};
-	class plane : public basic_plane, public collidable<plane>{};
-
-	class basic_aabb
+	class sphere
 	{
 	public:
-		math::vec3<float> point1 = {};
-		math::vec3<float> point2 = {};
-	public:
-		basic_aabb() = default;
-		basic_aabb(const math::vec3<float>& p1, const math::vec3<float>& p2);
-		basic_aabb(const basic_aabb&) = default;
-		basic_aabb(basic_aabb&&) = default;
-		~basic_aabb() = default;
-		basic_aabb& operator=(const basic_aabb&) = default;
-		basic_aabb& operator=(basic_aabb&&) = default;
-	};
-	class aabb : public basic_aabb, public collidable<aabb>
-	{
-	public:
-		using basic_aabb::basic_aabb;
-		using basic_aabb::operator=;
-		aabb(const basic_aabb& b);
-		aabb& operator=(const basic_aabb& b);
-	};
-
-	class basic_sphere
-	{
-	public:
-		math::vec3<float> point = {};
+		point point1 = {};
 		float radius = 0.0f;
 	public:
-		basic_sphere() = default;
-		basic_sphere(float r);
-		basic_sphere(const basic_sphere&) = default;
-		basic_sphere(basic_sphere&&) = default;
-		~basic_sphere() = default;
-		basic_sphere& operator=(const basic_sphere&) = default;
-		basic_sphere& operator=(basic_sphere&&) = default;
+		sphere() = default;
+		sphere(float r);
+		sphere(const sphere&) = default;
+		sphere(sphere&&) = default;
+		~sphere() = default;
+		sphere& operator=(const sphere&) = default;
+		sphere& operator=(sphere&&) = default;
 	};
-	class aabs : public basic_sphere, public collidable<aabs>
-	{
-	public:
-		using basic_sphere::basic_sphere;
-		using basic_sphere::operator=;
-		aabs(const basic_sphere& b);
-		aabs& operator=(const basic_sphere& b);
-	};
-
 
 }
 
diff --git a/include/engine/collision.hpp b/include/engine/collision.hpp
index 8d6b478..72ad185 100644
--- a/include/engine/collision.hpp
+++ b/include/engine/collision.hpp
@@ -19,6 +19,8 @@
 #ifndef OUR_DICK_ENGINE_COLLISION_HPP
 #define OUR_DICK_ENGINE_COLLISION_HPP
 
+#include "base_types.hpp"
+
 namespace egn{
 
 	static constexpr float default_collision_epsilon = 1.0e-10f;
@@ -42,20 +44,43 @@ namespace egn{
 	};
 
 
-	class point;
-	class aabb;
-	class aabs;
-	class line;
-	class plane;
+	namespace collision{
+
+		class point : public egn::point, public collidable<point>
+		{
+		public:
+			using egn::point::point;
+			using egn::point::operator=;
+		};
+		class line : public egn::line, public collidable<line>{};
+		class plane : public egn::plane, public collidable<plane>{};
+		class aabb : public egn::aabb, public collidable<aabb>
+		{
+		public:
+			using egn::aabb::aabb;
+			using egn::aabb::operator=;
+			aabb(const egn::aabb& b);
+			aabb& operator=(const egn::aabb& b);
+		};
+		class sphere : public egn::sphere, public collidable<sphere>
+		{
+		public:
+			using egn::sphere::sphere;
+			using egn::sphere::operator=;
+			sphere(const egn::sphere& b);
+			sphere& operator=(const egn::sphere& b);
+		};
+
+	}
 
 	class collidable_visitor
 	{
 	public:
-		virtual void visit(const aabb& a) = 0;
-		virtual void visit(const aabs& a) = 0;
-		virtual void visit(const line& a) = 0;
-		virtual void visit(const plane& a) = 0;
-		virtual void visit(const point& p) = 0;
+		virtual void visit(const collision::aabb& a) = 0;
+		virtual void visit(const collision::sphere& a) = 0;
+		virtual void visit(const collision::line& a) = 0;
+		virtual void visit(const collision::plane& a) = 0;
+		virtual void visit(const collision::point& p) = 0;
 	};
 
 	template<typename T>
@@ -67,38 +92,38 @@ namespace egn{
 		bool m_result = false;
 	public:
 		constexpr explicit collision_visitor(const T& l, float epsilon);
-		void visit(const aabb& a)override;
-		void visit(const aabs& a)override;
-		void visit(const line& a)override;
-		void visit(const plane& a)override;
-		void visit(const point& p)override;
+		void visit(const collision::aabb& a)override;
+		void visit(const collision::sphere& a)override;
+		void visit(const collision::line& a)override;
+		void visit(const collision::plane& a)override;
+		void visit(const collision::point& p)override;
 		constexpr bool result()const;
 	};
 
-	bool check_collision(const collidable_iface& l, const collidable_iface& r, float epsilon = default_collision_epsilon);
+	//bool check_collision(const collidable_iface& l, const collidable_iface& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const aabb& l, const aabb& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const aabb& l, const aabs& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const aabb& l, const sphere& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const aabb& l, const line& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const aabb& l, const plane& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const aabb& l, const point& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const aabs& l, const aabs& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const aabs& l, const aabb& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const aabs& l, const line& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const aabs& l, const plane& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const aabs& l, const point& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const sphere& l, const sphere& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const sphere& l, const aabb& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const sphere& l, const line& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const sphere& l, const plane& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const sphere& l, const point& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const line& l, const line& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const line& l, const aabb& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const line& l, const aabs& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const line& l, const sphere& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const line& l, const plane& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const line& l, const point& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const plane& l, const plane& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const plane& l, const aabb& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const plane& l, const aabs& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const plane& l, const sphere& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const plane& l, const line& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const plane& l, const point& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const point& l, const point& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const point& l, const aabb& r, float epsilon = default_collision_epsilon);
-	bool check_collision(const point& l, const aabs& r, float epsilon = default_collision_epsilon);
+	bool check_collision(const point& l, const sphere& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const point& l, const line& r, float epsilon = default_collision_epsilon);
 	bool check_collision(const point& l, const plane& r, float epsilon = default_collision_epsilon);
 
@@ -119,23 +144,23 @@ namespace egn{
 		m_l(l),
 		m_epsilon(epsilon){}
 	template<typename T>
-	void collision_visitor<T>::visit(const aabb& a){
+	void collision_visitor<T>::visit(const collision::aabb& a){
 		m_result = check_collision(m_l, a, m_epsilon);
 	}
 	template<typename T>
-	void collision_visitor<T>::visit(const aabs& a){
+	void collision_visitor<T>::visit(const collision::sphere& a){
 		m_result = check_collision(m_l, a, m_epsilon);
 	}
 	template<typename T>
-	void collision_visitor<T>::visit(const line& a){
+	void collision_visitor<T>::visit(const collision::line& a){
 		m_result = check_collision(m_l, a, m_epsilon);
 	}
 	template<typename T>
-	void collision_visitor<T>::visit(const plane& a){
+	void collision_visitor<T>::visit(const collision::plane& a){
 		m_result = check_collision(m_l, a, m_epsilon);
 	}
 	template<typename T>
-	void collision_visitor<T>::visit(const point& a){
+	void collision_visitor<T>::visit(const collision::point& a){
 		m_result = check_collision(m_l, a, m_epsilon);
 	}
 	template<typename T>
diff --git a/include/math/math_common.hpp b/include/math/math_common.hpp
index 4206928..6666fea 100644
--- a/include/math/math_common.hpp
+++ b/include/math/math_common.hpp
@@ -48,6 +48,27 @@ namespace math{
 		return (t * pi<T>()) / 180.0;
 	}
 
+	template<typename T>
+	static constexpr T clamp(const T& t, const T& min, const T& max){
+		if(t < min)
+			return min;
+		if(t > max)
+			return max;
+		return t;
+	}
+	template<typename T>
+	static constexpr T clamp_min(const T& t, const T& min){
+		if(t < min)
+			return min;
+		return t;
+	}
+	template<typename T>
+	static constexpr T clamp_max(const T& t, const T& max){
+		if(t > max)
+			return max;
+		return t;
+	}
+
 }
 constexpr long double operator"" _rad(long double f){
 	return f;
diff --git a/include/math/vec.hpp b/include/math/vec.hpp
index 274faef..a73aca3 100644
--- a/include/math/vec.hpp
+++ b/include/math/vec.hpp
@@ -78,6 +78,10 @@ namespace math{
 		constexpr void assign_(size_type offset, U&& u, Args&&... args);
 	};
 
+	template<typename T>
+	constexpr auto perp(const vector<T,2>& v);
+	template<typename T, typename U, size_t R1, size_t R2>
+	constexpr auto perp(const vector<T,R1>& left, const vector<U,R2>& right);
 	template<typename T, typename U>
 	constexpr auto cross(const vector<T,3>& left, const vector<U,3>& right);
 
diff --git a/include/math/vec.tpp b/include/math/vec.tpp
index 8f7f20f..e74b908 100644
--- a/include/math/vec.tpp
+++ b/include/math/vec.tpp
@@ -115,6 +115,14 @@ namespace math{
 		return (*this) / magnitude();
 	}
 
+	template<typename T>
+	constexpr auto perp(const vector<T,2>& v){
+		return vec2<T>(-v[1], v[0]);
+	}
+	template<typename T, typename U, size_t R1, size_t R2>
+	constexpr auto perp(const vector<T,R1>& left, const vector<U,R2>& right){
+		return (left[0] * right[1]) - (left[1] * right[0]);
+	}
 	template<typename T, typename U>
 	constexpr auto cross(const vector<T,3>& left, const vector<U,3>& right){
 		using res_t = decltype(left[0] * right[0]);
diff --git a/src/engine/base_types.cpp b/src/engine/base_types.cpp
index 325f5f8..ccaf062 100644
--- a/src/engine/base_types.cpp
+++ b/src/engine/base_types.cpp
@@ -20,26 +20,10 @@
 
 namespace egn{
 
-	basic_aabb::basic_aabb(const math::vec3<float>& p1, const math::vec3<float>& p2):
-		point1(p1),
-		point2(p2){}
-
-	aabb::aabb(const basic_aabb& b):
-		basic_aabb(b){}
-	aabb& aabb::operator=(const basic_aabb& b){
-		basic_aabb::operator=(b);
-		return *this;
-	}
-
-
-	basic_sphere::basic_sphere(float r):
+	aabb::aabb(const math::vec3<float>& p1, const math::vec3<float>& p2):
+		point1({p1.x(), p1.y(), p1.z()}),
+		point2({p2.x(), p2.y(), p2.z()}){}
+	sphere::sphere(float r):
 		radius(r){}
 
-	aabs::aabs(const basic_sphere& b):
-		basic_sphere(b){}
-	aabs& aabs::operator=(const basic_sphere& b){
-		basic_sphere::operator=(b);
-		return *this;
-	}
-
 }
diff --git a/src/engine/collision.cpp b/src/engine/collision.cpp
index 7f0af27..ea620c1 100644
--- a/src/engine/collision.cpp
+++ b/src/engine/collision.cpp
@@ -21,16 +21,32 @@
 
 namespace egn{
 
-	bool check_collision(const collidable_iface& l, const collidable_iface& r, float epsilon){
-		return l.check_collision(r, epsilon);
+	namespace collision{
+		aabb::aabb(const egn::aabb& b):
+			egn::aabb(b){}
+		aabb& aabb::operator=(const egn::aabb& b){
+			egn::aabb::operator=(b);
+			return *this;
+		}
+		sphere::sphere(const egn::sphere& b):
+			egn::sphere(b){}
+		sphere& sphere::operator=(const egn::sphere& b){
+			egn::sphere::operator=(b);
+			return *this;
+		}
+
 	}
+
+/*	bool check_collision(const collidable_iface& l, const collidable_iface& r, float epsilon){
+		return l.check_collision(r, epsilon);
+	}*/
 	bool check_collision(const aabb& l, const aabb& r, float epsilon){
 		(void)l;
 		(void)r;
 		(void)epsilon;
 		return false;
 	}
-	bool check_collision(const aabb& l, const aabs& r, float epsilon){
+	bool check_collision(const aabb& l, const sphere& r, float epsilon){
 		(void)l;
 		(void)r;
 		(void)epsilon;
@@ -54,28 +70,28 @@ namespace egn{
 		(void)epsilon;
 		return false;
 	}
-	bool check_collision(const aabs& l, const aabs& r, float epsilon){
+	bool check_collision(const sphere& l, const sphere& r, float epsilon){
 		(void)l;
 		(void)r;
 		(void)epsilon;
 		return false;
 	}
-	bool check_collision(const aabs& l, const aabb& r, float epsilon){
+	bool check_collision(const sphere& l, const aabb& r, float epsilon){
 		return check_collision(r, l, epsilon);
 	}
-	bool check_collision(const aabs& l, const line& r, float epsilon){
+	bool check_collision(const sphere& l, const line& r, float epsilon){
 		(void)l;
 		(void)r;
 		(void)epsilon;
 		return false;
 	}
-	bool check_collision(const aabs& l, const plane& r, float epsilon){
+	bool check_collision(const sphere& l, const plane& r, float epsilon){
 		(void)l;
 		(void)r;
 		(void)epsilon;
 		return false;
 	}
-	bool check_collision(const aabs& l, const point& r, float epsilon){
+	bool check_collision(const sphere& l, const point& r, float epsilon){
 		(void)l;
 		(void)r;
 		(void)epsilon;
@@ -87,7 +103,7 @@ namespace egn{
 		(void)epsilon;
 		return false;
 	}
-	bool check_collision(const line& l, const aabs& r, float epsilon){
+	bool check_collision(const line& l, const sphere& r, float epsilon){
 		return check_collision(r, l, epsilon);
 	}
 	bool check_collision(const line& l, const aabb& r, float epsilon){
@@ -125,7 +141,7 @@ namespace egn{
 	bool check_collision(const plane& l, const aabb& r, float epsilon){
 		return check_collision(r, l, epsilon);
 	}
-	bool check_collision(const plane& l, const aabs& r, float epsilon){
+	bool check_collision(const plane& l, const sphere& r, float epsilon){
 		return check_collision(r, l, epsilon);
 	}
 	bool check_collision(const plane& l, const line& r, float epsilon){
@@ -143,7 +159,7 @@ namespace egn{
 	bool check_collision(const point& l, const aabb& r, float epsilon){
 		return check_collision(r, l, epsilon);
 	}
-	bool check_collision(const point& l, const aabs& r, float epsilon){
+	bool check_collision(const point& l, const sphere& r, float epsilon){
 		return check_collision(r, l, epsilon);
 	}
 	bool check_collision(const point& l, const line& r, float epsilon){