diff --git a/a8/collision.cc b/a8/collision.cc
index 636314c..6c1d927 100644
--- a/a8/collision.cc
+++ b/a8/collision.cc
@@ -11,357 +11,6 @@
 
 namespace a8
 {
-    bool IntersectSegmentCircle(a8::Vec2 p0, a8::Vec2 p1, a8::Vec2 pos, float rad)
-    {
-        a8::Vec2 t = p1 - p0;
-        float d = std::max(t.Norm(), 0.0001f);
-        a8::Vec2 n = p0 - pos;
-        float v = n.Dot(t);
-        float z = n.Dot(n) - rad*rad;
-        if (z > 0 && v > 0) {
-            return false;
-        }
-        float u = v*v - z;
-        if (u < 0) {
-            return false;
-        }
-        float i = sqrt(u);
-        float x = -v - i;
-        if (x < 0 && (x = -v + i), x <= d) {
-            return true;
-        }
-        return false;
-    }
-
-    bool IntersectSegmentAabb(a8::Vec2 p0, a8::Vec2 p1, a8::Vec2 _min, a8::Vec2 _max)
-    {
-        a8::Vec2 c = (_min + _max) * 0.5f;
-        a8::Vec2 e = _max - c;
-        a8::Vec2 m = (p0 + p1) * 0.5f;
-        a8::Vec2 d = p1 - m;
-        m = m - c;
-
-        float adx = std::abs(d.x);
-        if (std::abs(m.x) > e.x + adx) {
-            return false;
-        }
-        float ady = std::abs(d.y);
-        if (std::abs(m.y) > e.y + ady) {
-            return false;
-        }
-        if (p0.x > p1.x) {
-            float tmp = p0.x;
-            p0.x = p1.x;
-            p1.x = tmp;
-        }
-        if (p0.y > p1.y) {
-            float tmp = p0.y;
-            p0.y = p1.y;
-            p1.y = tmp;
-        }
-        return IntersectAabbAabb(p0, p1, _min, _max);
-    }
-
-    bool IntersectAabbCircle(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_pos, float b_rad)
-    {
-        if (b_pos.x >= a_min.x && b_pos.x <= a_max.x &&
-            b_pos.y >= a_min.y && b_pos.y <= a_max.y) {
-            return true;
-        }
-        a8::Vec2 nearest_point(a8::Clamp(b_pos.x, a_min.x, a_max.x),
-                               a8::Clamp(b_pos.y, a_min.y, a_max.y));
-        a8::Vec2 i = b_pos - nearest_point;
-        float n = a8::LengthSqr(i);
-        return n < b_rad*b_rad;
-    }
-
-    bool IntersectAabbAabb(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_min, a8::Vec2 b_max)
-    {
-        a8::Vec2 a_v = (a_max - a_min) * 0.5f;
-        a8::Vec2 a_center = a_min + a_v;
-        a8::Vec2 b_v = (b_max - b_min) * 0.5f;
-        a8::Vec2 b_center = b_min + b_v;
-        a8::Vec2 z = b_center - a_center;
-        float u1 = a_v.x + b_v.x - std::abs(z.x);
-        float u2 = a_v.y + b_v.y - std::abs(z.y);
-        return u1 > 0.000001f && u2 > 0.000001;
-    }
-
-    bool IntersectAabbObb(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_pos, float rotate)
-    {
-        struct Segment
-        {
-            a8::Vec2 point1;
-            a8::Vec2 point2;
-            a8::Vec2 dir;
-        };
-        std::vector<Segment> a_edges;
-        std::vector<Segment> b_edges;
-        for (int i = 0; i < 3; ++i) {
-            Segment seg;
-            switch (i) {
-            case 0:
-                {
-                    seg.point1 = a_min;
-                    seg.point2 = a_min + a8::Vec2(a_max.x - a_min.x, 0);
-                    seg.dir = seg.point2 - seg.point1;
-                }
-                break;
-            case 1:
-                {
-                    seg.point1 = a_min + a8::Vec2(a_max.x - a_min.x, 0);
-                    seg.point2 = a_max;
-                    seg.dir = seg.point2 - seg.point1;
-                }
-                break;
-            case 2:
-                {
-                    seg.point1 = a_max;
-                    seg.point2 = a_min + a8::Vec2(0, a_max.y - a_min.y);
-                    seg.dir = seg.point2 - seg.point1;
-                }
-                break;
-            case 3:
-                {
-                    seg.point1 = a_min + a8::Vec2(0, a_max.y - a_min.y);
-                    seg.point2 = a_min;
-                    seg.dir = seg.point2 - seg.point1;
-                }
-                break;
-            default:
-                {
-                    abort();
-                }
-            }
-            a_edges.push_back(seg);
-        }
-        for (int i = 0; i < 3; ++i) {
-            Segment seg;
-            switch (i) {
-            case 0:
-                {
-                    seg.point1 = a_min;
-                    seg.point2 = a_min + a8::Vec2(a_max.x - a_min.x, 0);
-                    seg.dir = seg.point2 - seg.point1;
-                }
-                break;
-            case 1:
-                {
-                    seg.point1 = a_min + a8::Vec2(a_max.x - a_min.x, 0);
-                    seg.point2 = a_max;
-                    seg.dir = seg.point2 - seg.point1;
-                }
-                break;
-            case 2:
-                {
-                    seg.point1 = a_max;
-                    seg.point2 = a_min + a8::Vec2(0, a_max.y - a_min.y);
-                    seg.dir = seg.point2 - seg.point1;
-                }
-                break;
-            case 3:
-                {
-                    seg.point1 = a_min + a8::Vec2(0, a_max.y - a_min.y);
-                    seg.point2 = a_min;
-                    seg.dir = seg.point2 - seg.point1;
-                }
-                break;
-            default:
-                {
-                    abort();
-                }
-            }
-            b_edges.push_back(seg);
-        }
-        #if 0
-        auto GetProjectionWithAxis =
-            [] (std::vector<a8::Vec2> vertices, a8::Vec2 axis) -> a8::Vec2 {
-                axis.Normalize();
-                float _min = vertices[0].Dot(axis);
-                float _max = _min;
-                for (a8::Vec2& v : vertices) {
-
-                }
-            };
-        #endif
-        return false;
-    }
-
-    bool IntersectAabbArc(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_pos, float width)
-    {
-        return false;
-    }
-
-    bool IntersectCircleArc(a8::Vec2 a_pos,
-                            float a_rad,
-                            a8::Vec2 b_pos,
-                            float b_rad,
-                            float b_angle,
-                            float b_width,
-                            float b_height)
-    {
-        float distance = b_pos.Distance(a_pos);
-        float _min = b_rad - b_height / 2 - a_rad;
-        float _max = b_rad + b_height / 2 + a_rad;
-        if (distance < _min) {
-            return false;
-        }
-        if (distance > _max) {
-            return false;
-        }
-        //float angle = (a_pos - b_pos).CalcAngleEx(a8::Vec2::UP);
-        return false;
-    }
-
-    bool IntersectCircleCircle(a8::Vec2 a_pos, float a_rad, a8::Vec2 b_pos, float b_rad)
-    {
-        float t = a_rad + b_rad;
-        a8::Vec2 d = b_pos - a_pos;
-        float n = a8::LengthSqr(d);
-        return n < t*t;
-    }
-
-    bool IntersectSectorCircle(a8::Vec2 a_pos, float angle, float a_rad, a8::Vec2 b_pos, float b_rad)
-    {
-        {
-            a8::Vec2 d = b_pos - a_pos;
-            float n = a8::LengthSqr(d);
-            if (n < a_rad || n < b_rad) {
-                return true;
-            }
-            if (n > a_rad + b_rad) {
-                return false;
-            }
-        }
-        {
-
-        }
-        return false;
-    }
-
-    bool IntersectSectorAabb(a8::Vec2 a_pos, float angle, float a_rad, a8::Vec2 b_min, a8::Vec2 b_max)
-    {
-        return false;
-    }
-
-    bool CircleContainCircle(glm::vec2 a_pos, float a_rad, glm::vec2 b_pos, float b_rad)
-    {
-        float distance = glm::length(a_pos - b_pos);
-        return distance < a_rad - b_rad;
-    }
-
-    bool CalcCircleAabbSafePoint(a8::Vec2 a_pos, float b_rad, a8::Vec2 b_min, a8::Vec2 b_max,
-                                 a8::Vec2& new_pos)
-    {
-        new_pos = a_pos;
-        bool at_left = std::abs(a_pos.x - b_min.x) < std::abs(a_pos.x - b_max.x);
-        bool at_down = std::abs(a_pos.y - b_min.y) < std::abs(a_pos.y - b_max.y);
-        float x_len = at_left ? std::abs(a_pos.x - b_min.x) : std::abs(a_pos.x - b_max.x);
-        float y_len = at_down ? std::abs(a_pos.y - b_min.y) : std::abs(a_pos.y - b_max.y);
-        if (at_left) {
-            if (x_len < y_len) {
-                //左
-                new_pos.x = b_min.x - b_rad - 1;
-            } else {
-                if (at_down) {
-                    new_pos.y = b_min.y - b_rad - 1;
-                } else {
-                    new_pos.y = b_max.y + b_rad + 1;
-                }
-            }
-        } else {
-            if (x_len < y_len) {
-                //右
-                new_pos.x = b_max.x + b_rad + 1;
-            } else {
-                if (at_down) {
-                    new_pos.y = b_min.y - b_rad - 1;
-                } else {
-                    new_pos.y = b_max.y + b_rad + 1;
-                }
-            }
-        }
-        return true;
-    }
-
-    bool CalcCircleCircleSafePoint(a8::Vec2 a_pos, float a_rad, a8::Vec2 b_pos, float b_rad,
-                                   a8::Vec2& new_pos)
-    {
-        a8::Vec2 dir = a_pos - b_pos;
-        dir.Normalize();
-        new_pos = b_pos + dir*(a_rad + b_rad) + 1;
-        return true;
-    }
-
-    bool CalcAabbAabbSafePoint(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_min, a8::Vec2 b_max,
-                               a8::Vec2& new_pos)
-    {
-        a8::Vec2 a_pos = a_min + (a_max - a_min)/2.0f;
-        new_pos = a_pos;
-        bool at_left = std::abs(a_pos.x - b_min.x) < std::abs(a_pos.x - b_max.x);
-        bool at_down = std::abs(a_pos.y - b_min.y) < std::abs(a_pos.y - b_max.y);
-        float x_len = at_left ? std::abs(a_pos.x - b_min.x) : std::abs(a_pos.x - b_max.x);
-        float y_len = at_down ? std::abs(a_pos.y - b_min.y) : std::abs(a_pos.y - b_max.y);
-        if (at_left) {
-            if (x_len < y_len) {
-                //左
-                new_pos.x = b_min.x - (a_max.x - a_min.x)/2.0f - 1;
-            } else {
-                if (at_down) {
-                    new_pos.y = b_min.y - (a_max.y - a_min.y)/2.0f - 1;
-                } else {
-                    new_pos.y = b_max.y + (a_max.y - a_min.y)/2.0f + 1;
-                }
-            }
-        } else {
-            if (x_len < y_len) {
-                //右
-                new_pos.x = b_max.x + (a_max.x - a_min.x)/2.0f + 1;
-            } else {
-                if (at_down) {
-                    new_pos.y = b_min.y - (a_max.y - a_min.y)/2.0f - 1;
-                } else {
-                    new_pos.y = b_max.y + (a_max.y - a_min.y)/2.0f + 1;
-                }
-            }
-        }
-        return true;
-    }
-
-    bool CalcAabbCircleSafePoint(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_pos, float b_rad,
-                                 a8::Vec2& new_pos)
-    {
-        a8::Vec2 a_pos = a_min + (a_max - a_min)/2.0f;
-        new_pos = a_pos;
-        bool at_left = std::abs(a_min.x - b_pos.x) < std::abs(a_max.x - b_pos.x);
-        bool at_down = std::abs(a_min.y - b_pos.y) < std::abs(a_max.y - b_pos.y);
-        float x_len = at_left ? std::abs(a_min.x - b_pos.x) : std::abs(a_max.x - b_pos.x);
-        float y_len = at_down ? std::abs(a_min.y - b_pos.y) : std::abs(a_max.y - b_pos.y);
-        if (at_left) {
-            if (x_len < y_len) {
-                //左
-                new_pos.x = b_pos.x - (a_max.x - a_min.x)/2.0f - 1;
-            } else {
-                if (at_down) {
-                    new_pos.y = b_pos.y - (a_max.y - a_min.y)/2.0f - 1;
-                } else {
-                    new_pos.y = b_pos.y + (a_max.y - a_min.y)/2.0f + 1;
-                }
-            }
-        } else {
-            if (x_len < y_len) {
-                //右
-                new_pos.x = b_pos.x + (a_max.x - a_min.x)/2.0f + 1;
-            } else {
-                if (at_down) {
-                    new_pos.y = b_pos.y - (a_max.y - a_min.y)/2.0f - 1;
-                } else {
-                    new_pos.y = b_pos.y + (a_max.y - a_min.y)/2.0f + 1;
-                }
-            }
-        }
-        return true;
-    }
 
     bool IntersectCylinderCylinder(const glm::vec3& a_pos, float a_rad, float a_height,
                                    const glm::vec3& b_pos, float b_rad, float b_height)
@@ -374,4 +23,10 @@ namespace a8
         return (a_pos.y - b_pos.y) < (a_height + b_height) / 2.0f;
     }
 
+    bool CircleContainCircle(glm::vec2 a_pos, float a_rad, glm::vec2 b_pos, float b_rad)
+    {
+        float distance = glm::length(a_pos - b_pos);
+        return distance < a_rad - b_rad;
+    }
+
 }
diff --git a/a8/collision.h b/a8/collision.h
index ac5a81f..74e2fe1 100644
--- a/a8/collision.h
+++ b/a8/collision.h
@@ -1,40 +1,13 @@
 #pragma once
 
-#include <a8/vec2.h>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
 
 namespace a8
 {
-    bool IntersectSegmentCircle(a8::Vec2 p0, a8::Vec2 p1, a8::Vec2 pos, float rad);
-    bool IntersectSegmentAabb(a8::Vec2 p0, a8::Vec2 p1, a8::Vec2 _min, a8::Vec2 _max);
-    bool IntersectAabbCircle(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_pos, float b_rad);
-    bool IntersectAabbAabb(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_min, a8::Vec2 b_max);
-    bool IntersectAabbObb(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_pos, float rotate);
-    bool IntersectAabbArc(a8::Vec2 a_min,
-                          a8::Vec2 a_max,
-                          a8::Vec2 b_pos,
-                          float b_rad,
-                          float b_width,
-                          float b_height);
-    bool IntersectCircleCircle(a8::Vec2 a_pos, float a_rad, a8::Vec2 b_pos, float b_rad);
+
     bool IntersectCylinderCylinder(const glm::vec3& a_pos, float a_rad, float a_height,
                                    const glm::vec3& b_pos, float b_rad, float b_height);
-
-    bool IntersectCircleArc(a8::Vec2 a_pos,
-                            float a_rad,
-                            a8::Vec2 b_pos,
-                            float b_rad,
-                            float b_angle,
-                            float b_width,
-                            float b_height);
-    bool IntersectSectorCircle(a8::Vec2 a_pos, float angle, float a_rad, a8::Vec2 b_pos, float b_rad);
-    bool IntersectSectorAabb(a8::Vec2 a_pos, float angle, float a_rad, a8::Vec2 b_min, a8::Vec2 b_max);
     bool CircleContainCircle(glm::vec2 a_pos, float a_rad, glm::vec2 b_pos, float b_rad);
-    bool CalcCircleAabbSafePoint(a8::Vec2 a_pos, float a_rad, a8::Vec2 b_min, a8::Vec2 b_max,
-                                 a8::Vec2& new_pos);
-    bool CalcCircleCircleSafePoint(a8::Vec2 a_pos, float a_rad, a8::Vec2 b_pos, float b_rad,
-                                   a8::Vec2& new_pos);
-    bool CalcAabbAabbSafePoint(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_min, a8::Vec2 b_max,
-                               a8::Vec2& new_pos);
-    bool CalcAabbCircleSafePoint(a8::Vec2 a_min, a8::Vec2 a_max, a8::Vec2 b_pos, float b_rad,
-                                 a8::Vec2& new_pos);
+
 }
diff --git a/a8/vec2.cc b/a8/vec2.cc
deleted file mode 100644
index 56ed45a..0000000
--- a/a8/vec2.cc
+++ /dev/null
@@ -1,127 +0,0 @@
-#include <math.h>
-#include <a8/a8.h>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/vec2.hpp>
-#include <Eigen/Core>
-#include <Eigen/Dense>
-
-#include <a8/vec2.h>
-
-namespace a8
-{
-    const Vec2 Vec2::UP = Vec2(0.0f, 1.0f);
-    const Vec2 Vec2::RIGHT = Vec2(1.0f, 0.0f);
-    const Vec2 Vec2::DOWN = Vec2(0.0f, -1.0f);
-    const Vec2 Vec2::LEFT = Vec2(-1.0f, 0.0f);
-
-    void Vec2::Normalize()
-    {
-        glm::vec2 v = glm::normalize(glm::vec2(x, y));
-        if (isnan(v[0])) {
-            abort();
-        }
-        if (isnan(v[1])) {
-            abort();
-        }
-        x = v[0];
-        y = v[1];
-    }
-
-    bool Vec2::operator == (const Vec2& b) const
-    {
-        return std::abs(x - b.x) < 0.01f && std::abs(y - b.y) < 0.01f;
-    }
-
-    Vec2 Vec2::operator + (const Vec2& b) const
-    {
-        glm::vec2 v = glm::vec2(x, y) + glm::vec2(b.x, b.y);
-        return Vec2(v[0], v[1]);
-    }
-
-    Vec2 Vec2::operator - (const Vec2& b) const
-    {
-        glm::vec2 v = glm::vec2(x, y) - glm::vec2(b.x, b.y);
-        return Vec2(v[0], v[1]);
-    }
-
-    Vec2 Vec2::operator * (float scale) const
-    {
-        glm::vec2 v = glm::vec2(x, y) * scale;
-        return Vec2(v[0], v[1]);
-    }
-
-    Vec2 Vec2::operator / (float scale) const
-    {
-        glm::vec2 v = glm::vec2(x, y) / scale;
-        return Vec2(v[0], v[1]);
-    }
-
-    void Vec2::Rotate(float angle)
-    {
-        Eigen::Vector3f v(x, y, 0);
-        v = Eigen::AngleAxisf(angle * 3.1415926f, Eigen::Vector3f::UnitZ()) * v;
-        x = v[0];
-        y = v[1];
-    }
-
-    float Vec2::CalcAngle(const Vec2& b) const
-    {
-        float a1 = acos(Dot(b) / Norm() / b.Norm());
-        bool at_right_side = Vec2::RIGHT.Dot(*this) > 0.0001f;
-        if (at_right_side) {
-            a1 = -a1;
-        }
-        return a1 / 3.1415926f;
-    }
-
-    float Vec2::CalcAngleEx(const Vec2& b) const
-    {
-        float a1 = acos(Dot(b) / Norm() / b.Norm());
-        return a1 / 3.1415926f;
-    }
-
-    Vec2 Vec2::FromAngle(float angle)
-    {
-        Vec2 vec2;
-        float hu = angle * 3.1415926f / 180.0f;
-        vec2.x = cos(hu);
-        vec2.y = sin(hu);
-        vec2.Normalize();
-        return vec2;
-    }
-
-    float Vec2::Distance(const Vec2& b) const
-    {
-        Vec2 v = b - *this;
-        return v.Norm();
-    }
-
-    float Vec2::ManhattanDistance(const Vec2& b)
-    {
-        float distance = std::fabs(x - b.x) + std::fabs(y - b.y);
-        return distance;
-    }
-
-    Vec2 Vec2::Perp()
-    {
-        return Vec2(y, -x);
-    }
-
-    float Vec2::Dot(const Vec2& v) const
-    {
-        return x*v.x + y*v.y;
-    }
-
-    float Vec2::Norm() const
-    {
-        return fabs(sqrt(x*x + y*y));
-    }
-
-    bool Vec2::IsZero() const
-    {
-        return fabs(x) < 0.00001f && fabs(y) < 0.00001f;
-    }
-
-}
diff --git a/a8/vec2.h b/a8/vec2.h
deleted file mode 100644
index daa0d6e..0000000
--- a/a8/vec2.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-namespace a8
-{
-    struct Vec2
-    {
-        float x = 0.0f;
-        float y = 0.0f;
-
-        Vec2(float _x = 0.0f, float _y = 0.0f):x(_x), y(_y) {};
-
-        void Normalize();
-        void Rotate(float angle);
-        float CalcAngle(const Vec2& b) const;
-        float CalcAngleEx(const Vec2& b) const;
-        static Vec2 FromAngle(float angle);
-        float Distance(const Vec2& b) const;
-        float ManhattanDistance(const Vec2& b);
-
-        bool operator == (const Vec2& b) const;
-        Vec2 operator + (const Vec2& b) const;
-        Vec2 operator - (const Vec2& b) const;
-        Vec2 operator * (float scale) const;
-        Vec2 operator / (float scale) const;
-        Vec2 Perp();
-        float Dot(const Vec2& v) const;
-        float Norm() const;
-        bool IsZero() const;
-
-        static const Vec2 UP;
-        static const Vec2 DOWN;
-        static const Vec2 LEFT;
-        static const Vec2 RIGHT;
-    };
-}
diff --git a/a8/vec3.cc b/a8/vec3.cc
deleted file mode 100644
index ac3cd43..0000000
--- a/a8/vec3.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <math.h>
-#include <a8/a8.h>
-
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/vec3.hpp>
-
-#include <Eigen/Core>
-#include <Eigen/Dense>
-
-
-#include <a8/vec3.h>
-
-namespace a8
-{
-
-    void Vec3::RotateX(float angle)
-    {
-        Eigen::Vector3f v(x, y, z);
-        v = Eigen::AngleAxisf(angle * 3.1415926f, Eigen::Vector3f::UnitX()) * v;
-        x = v[0];
-        y = v[1];
-        z = v[2];
-    }
-
-    void Vec3::RotateY(float angle)
-    {
-        Eigen::Vector3f v(x, y, z);
-        v = Eigen::AngleAxisf(angle * 3.1415926f, Eigen::Vector3f::UnitY()) * v;
-        x = v[0];
-        y = v[1];
-        z = v[2];
-    }
-
-    void Vec3::RotateZ(float angle)
-    {
-        Eigen::Vector3f v(x, y, z);
-        v = Eigen::AngleAxisf(angle * 3.1415926f, Eigen::Vector3f::UnitZ()) * v;
-        x = v[0];
-        y = v[1];
-        z = v[2];
-    }
-
-}
diff --git a/a8/vec3.h b/a8/vec3.h
deleted file mode 100644
index 68c3247..0000000
--- a/a8/vec3.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-namespace a8
-{
-    struct Vec3
-    {
-        float x = 0.0f;
-        float y = 0.0f;
-        float z = 0.0f;
-
-        Vec3(float _x = 0.0f, float _y = 0.0f, float _z = 0.0f):x(_x), y(_y), z(_z) {};
-        void RotateX(float angle);
-        void RotateY(float angle);
-        void RotateZ(float angle);
-    };
-}