PolyMesh

GenerateMesh.cs

using UnityEngine;
using System.Collections.Generic;

[ExecuteInEditMode]
[RequireComponent(typeof(MeshRenderer))]
[RequireComponent(typeof(MeshFilter))]
public class GenerateMesh : MonoBehaviour
{
	/// <summary>
	/// パス座標
	/// </summary>
	public List<Vector3> keyPoints = new List<Vector3>();
	/// <summary>
	/// 頂点パス座標
	/// </summary>
	public List<Vector3> curvePoints = new List<Vector3>();
	/// <summary>
	/// 各頂点間が曲線を持つかどうか
	/// </summary>
	public List<bool> isCurve = new List<bool>();
	/// <summary>
	/// Mesh Collider
	/// </summary>
	public MeshCollider meshCollider;
	[Range(0.01f, 1)] public float curveDetail = 0.1f;
	public float colliderDepth = 1;
	public bool buildColliderEdges = true;
	public bool buildColliderFront;
	/// <summary>
	/// テクスチャの描画位置
	/// </summary>
	public Vector2 uvPosition;
	/// <summary>
	/// UVの拡大率
	/// </summary>
	public float uvScale = 1;
	/// <summary>
	/// UVの回転率
	/// </summary>
	public float uvRotation;
	
	public List<Vector3> GetEdgePoints() {
		//Build the point list and calculate curves
		var points = new List<Vector3>();
		for (int i = 0; i < keyPoints.Count; i++) {
			if (isCurve[i]) {
				//Get the curve control point
				var a = keyPoints[i];
				var c = keyPoints[(i + 1) % keyPoints.Count];
				var b = Bezier.Control(a, c, curvePoints[i]);
				
				//Build the curve
				var count = Mathf.Ceil(1 / curveDetail);
				for (int j = 0; j < count; j++)
				{
					var t = (float)j / count;
					points.Add(Bezier.Curve(a, b, c, t));
				}
			}
			else
				points.Add(keyPoints[i]);
		}
		return points;
	}
	
	public void BuildMesh()
	{
		var points = GetEdgePoints();
		var vertices = points.ToArray();
		
		//Build the index array
		var indices = new List<int>();
		while (indices.Count < points.Count)
			indices.Add(indices.Count);

		//Build the triangle array
		var triangles = Triangulate.Points(points);
		
		//Build the uv array
		var scale = uvScale != 0 ? (1 / uvScale) : 0;
		var matrix = Matrix4x4.TRS(-uvPosition, Quaternion.Euler(0, 0, uvRotation), new Vector3(scale, scale, 1));
		var uv = new Vector2[points.Count];
		for (int i = 0; i < uv.Length; i++)
		{
			var p = matrix.MultiplyPoint(points[i]);
			uv[i] = new Vector2(p.x, p.y);
		}
		
		//Find the mesh (create it if it doesn't exist)
		var meshFilter = GetComponent<MeshFilter>();
		var mesh = meshFilter.sharedMesh;
		if (mesh == null)
		{
			mesh = new Mesh();
			mesh.name = "PolySprite_Mesh";
			meshFilter.mesh = mesh;
		}
		
		//Update the mesh
		mesh.Clear();
		mesh.vertices = vertices;
		mesh.uv = uv;
		mesh.triangles = triangles;
		mesh.RecalculateNormals();
		mesh.Optimize();
		
		//Update collider after the mesh is updated
		UpdateCollider(points, triangles);
	}
	
	void UpdateCollider(List<Vector3> points, int[] tris)
	{
		//Update the mesh collider if there is one
		if (meshCollider != null)
		{
			var vertices = new List<Vector3>();
			var triangles = new List<int>();
			
			if (buildColliderEdges)
			{
				//Build vertices array
				var offset = new Vector3(0, 0, colliderDepth / 2);
				for (int i = 0; i < points.Count; i++)
				{
					vertices.Add(points[i] + offset);
					vertices.Add(points[i] - offset);
				}
				
				//Build triangles array
				for (int a = 0; a < vertices.Count; a += 2)
				{
					var b = (a + 1) % vertices.Count;
					var c = (a + 2) % vertices.Count;
					var d = (a + 3) % vertices.Count;
					triangles.Add(a);
					triangles.Add(c);
					triangles.Add(b);
					triangles.Add(c);
					triangles.Add(d);
					triangles.Add(b);
				}
			}
			
			if (buildColliderFront)
			{
				for (int i = 0; i < tris.Length; i++)
					tris[i] += vertices.Count;
				vertices.AddRange(points);
				triangles.AddRange(tris);
			}
			
			//Find the mesh (create it if it doesn't exist)
			var mesh = meshCollider.sharedMesh;
			if (mesh == null)
			{
				mesh = new Mesh();
				mesh.name = "PolySprite_Collider";
			}
			
			//Update the mesh
			mesh.Clear();
			mesh.vertices = vertices.ToArray();
			mesh.triangles = triangles.ToArray();
			mesh.RecalculateNormals();
			mesh.Optimize();
			meshCollider.sharedMesh = null;
			meshCollider.sharedMesh = mesh;
		}
	}
	
	bool IsRightTurn(List<Vector3> points, int a, int b, int c)
	{
		var ab = points[b] - points[a];
		var bc = points[c] - points[b];
		return (ab.x * bc.y - ab.y * bc.x) < 0;
	}
	
	bool IntersectsExistingLines(List<Vector3> points, Vector3 a, Vector3 b)
	{
		for (int i = 0; i < points.Count; i++)
			if (LinesIntersect(points, a, b, points[i], points[(i + 1) % points.Count]))
				return true;
		return false;
	}
	
	bool LinesIntersect(List<Vector3> points, Vector3 point1, Vector3 point2, Vector3 point3, Vector3 point4)
	{
		if (point1 == point3 || point1 == point4 || point2 == point3 || point2 == point4)
			return false;
		
		float ua = (point4.x - point3.x) * (point1.y - point3.y) - (point4.y - point3.y) * (point1.x - point3.x);
		float ub = (point2.x - point1.x) * (point1.y - point3.y) - (point2.y - point1.y) * (point1.x - point3.x);
		float denominator = (point4.y - point3.y) * (point2.x - point1.x) - (point4.x - point3.x) * (point2.y - point1.y);
		
		if (Mathf.Abs(denominator) <= 0.00001f)
		{
			if (Mathf.Abs(ua) <= 0.00001f && Mathf.Abs(ub) <= 0.00001f)
				return true;
		}
		else
		{
			ua /= denominator;
			ub /= denominator;
			
			if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1)
				return true;
		}
		
		return false;
	}
}

public static class Bezier
{
	public static float Curve(float from, float control, float to, float t)
	{
		return from * (1 - t) * (1 - t) + control * 2 * (1 - t) * t + to * t * t;
	}
	public static Vector3 Curve(Vector3 from, Vector3 control, Vector3 to, float t)
	{
		from.x = Curve(from.x, control.x, to.x, t);
		from.y = Curve(from.y, control.y, to.y, t);
		from.z = Curve(from.z, control.z, to.z, t);
		return from;
	}
	
	public static Vector3 Control(Vector3 from, Vector3 to, Vector3 curve)
	{
		//var center = Vector3.Lerp(from, to, 0.5f);
		//return center + (curve - center) * 2;
		var axis = Vector3.Normalize(to - from);
		var dot = Vector3.Dot(axis, curve - from);
		var linePoint = from + axis * dot;
		return linePoint + (curve - linePoint) * 2;
	}
}

public static class Triangulate
{
	public static int[] Points(List<Vector3> points)
	{
		var indices = new List<int>();
		
		int n = points.Count;
		if (n < 3)
			return indices.ToArray();
		
		int[] V = new int[n];
		if (Area(points) > 0)
		{
			for (int v = 0; v < n; v++)
				V[v] = v;
		}
		else
		{
			for (int v = 0; v < n; v++)
				V[v] = (n - 1) - v;
		}
		
		int nv = n;
		int count = 2 * nv;
		for (int m = 0, v = nv - 1; nv > 2; )
		{
			if ((count--) <= 0)
				return indices.ToArray();
			
			int u = v;
			if (nv <= u)
				u = 0;
			v = u + 1;
			if (nv <= v)
				v = 0;
			int w = v + 1;
			if (nv <= w)
				w = 0;
			
			if (Snip(points, u, v, w, nv, V))
			{
				int a, b, c, s, t;
				a = V[u];
				b = V[v];
				c = V[w];
				indices.Add(a);
				indices.Add(b);
				indices.Add(c);
				m++;
				for (s = v, t = v + 1; t < nv; s++, t++)
					V[s] = V[t];
				nv--;
				count = 2 * nv;
			}
		}
		
		indices.Reverse();
		return indices.ToArray();
	}
	
	static float Area(List<Vector3> points)
	{
		int n = points.Count;
		float A = 0.0f;
		for (int p = n - 1, q = 0; q < n; p = q++)
		{
			Vector3 pval = points[p];
			Vector3 qval = points[q];
			A += pval.x * qval.y - qval.x * pval.y;
		}
		return (A * 0.5f);
	}
	
	static bool Snip(List<Vector3> points, int u, int v, int w, int n, int[] V)
	{
		int p;
		Vector3 A = points[V[u]];
		Vector3 B = points[V[v]];
		Vector3 C = points[V[w]];
		if (Mathf.Epsilon > (((B.x - A.x) * (C.y - A.y)) - ((B.y - A.y) * (C.x - A.x))))
			return false;
		for (p = 0; p < n; p++)
		{
			if ((p == u) || (p == v) || (p == w))
				continue;
			Vector3 P = points[V[p]];
			if (InsideTriangle(A, B, C, P))
				return false;
		}
		return true;
	}
	
	static bool InsideTriangle(Vector2 A, Vector2 B, Vector2 C, Vector2 P)
	{
		float ax, ay, bx, by, cx, cy, apx, apy, bpx, bpy, cpx, cpy;
		float cCROSSap, bCROSScp, aCROSSbp;
		
		ax = C.x - B.x; ay = C.y - B.y;
		bx = A.x - C.x; by = A.y - C.y;
		cx = B.x - A.x; cy = B.y - A.y;
		apx = P.x - A.x; apy = P.y - A.y;
		bpx = P.x - B.x; bpy = P.y - B.y;
		cpx = P.x - C.x; cpy = P.y - C.y;
		
		aCROSSbp = ax * bpy - ay * bpx;
		cCROSSap = cx * apy - cy * apx;
		bCROSScp = bx * cpy - by * cpx;
		
		return ((aCROSSbp >= 0.0f) && (bCROSScp >= 0.0f) && (cCROSSap >= 0.0f));
	}
}

PolyMesh.cs

using UnityEngine;
using System.Collections.Generic;

//コンポーネントを自動的に追加
[RequireComponent(typeof(MeshFilter))]
public class PolyMesh : MonoBehaviour
{
	/// <summary>
	/// 
	/// </summary>
	public List<Vector3> keyPoints = new List<Vector3>();
	
	/// <summary>
	/// 
	/// </summary>
	public List<Vector3> curvePoints = new List<Vector3>();
	
	/// <summary>
	/// 
	/// </summary>
	public List<bool> isCurve = new List<bool>();
	
	/// <summary>
	/// 
	/// </summary>
	public MeshCollider meshCollider;
	
	/// <summary>
	/// 
	/// </summary>
	[Range(0.01f, 1)] public float curveDetail = 0.1f;
	
	/// <summary>
	/// 
	/// </summary>
	public float colliderDepth = 1;
	
	/// <summary>
	/// 
	/// </summary>
	public bool buildColliderEdges = true;
	
	/// <summary>
	/// 
	/// </summary>
	public bool buildColliderFront;
	
	/// <summary>
	/// 
	/// </summary>
	public Vector2 uvPosition;
	
	/// <summary>
	/// 
	/// </summary>
	public float uvScale = 1;
	
	/// <summary>
	/// 
	/// </summary>
	public float uvRotation;
	
	public List<Vector3> GetEdgePoints()
	{
		//Build the point list and calculate curves
		var points = new List<Vector3>();
		for (int i = 0; i < keyPoints.Count; i++)
		{
			if (isCurve[i])
			{
				//Get the curve control point
				var a = keyPoints[i];
				var c = keyPoints[(i + 1) % keyPoints.Count];
				var b = Bezier.Control(a, c, curvePoints[i]);
				
				//Build the curve
				var count = Mathf.Ceil(1 / curveDetail);
				for (int j = 0; j < count; j++)
				{
					var t = (float)j / count;
					points.Add(Bezier.Curve(a, b, c, t));
				}
			}
			else
				points.Add(keyPoints[i]);
		}
		return points;
	}
	
	public void BuildMesh()
	{
		var points = GetEdgePoints();
		var vertices = points.ToArray();
		
		//Build the index array
		var indices = new List<int>();
		while (indices.Count < points.Count)
			indices.Add(indices.Count);

		//Build the triangle array
		var triangles = Triangulate.Points(points);
		
		//Build the uv array
		var scale = uvScale != 0 ? (1 / uvScale) : 0;
		var matrix = Matrix4x4.TRS(-uvPosition, Quaternion.Euler(0, 0, uvRotation), new Vector3(scale, scale, 1));
		var uv = new Vector2[points.Count];
		for (int i = 0; i < uv.Length; i++)
		{
			var p = matrix.MultiplyPoint(points[i]);
			uv[i] = new Vector2(p.x, p.y);
		}
		
		//Find the mesh (create it if it doesn't exist)
		var meshFilter = GetComponent<MeshFilter>();
		var mesh = meshFilter.sharedMesh;
		if (mesh == null)
		{
			mesh = new Mesh();
			mesh.name = "PolySprite_Mesh";
			meshFilter.mesh = mesh;
		}
		
		//Update the mesh
		mesh.Clear();
		mesh.vertices = vertices;
		mesh.uv = uv;
		mesh.triangles = triangles;
		mesh.RecalculateNormals();
		mesh.Optimize();
		
		//Update collider after the mesh is updated
		UpdateCollider(points, triangles);
	}
	
	void UpdateCollider(List<Vector3> points, int[] tris)
	{
		//Update the mesh collider if there is one
		if (meshCollider != null)
		{
			var vertices = new List<Vector3>();
			var triangles = new List<int>();
			
			if (buildColliderEdges)
			{
				//Build vertices array
				var offset = new Vector3(0, 0, colliderDepth / 2);
				for (int i = 0; i < points.Count; i++)
				{
					vertices.Add(points[i] + offset);
					vertices.Add(points[i] - offset);
				}
				
				//Build triangles array
				for (int a = 0; a < vertices.Count; a += 2)
				{
					var b = (a + 1) % vertices.Count;
					var c = (a + 2) % vertices.Count;
					var d = (a + 3) % vertices.Count;
					triangles.Add(a);
					triangles.Add(c);
					triangles.Add(b);
					triangles.Add(c);
					triangles.Add(d);
					triangles.Add(b);
				}
			}
			
			if (buildColliderFront)
			{
				for (int i = 0; i < tris.Length; i++)
					tris[i] += vertices.Count;
				vertices.AddRange(points);
				triangles.AddRange(tris);
			}
			
			//Find the mesh (create it if it doesn't exist)
			var mesh = meshCollider.sharedMesh;
			if (mesh == null)
			{
				mesh = new Mesh();
				mesh.name = "PolySprite_Collider";
			}
			
			//Update the mesh
			mesh.Clear();
			mesh.vertices = vertices.ToArray();
			mesh.triangles = triangles.ToArray();
			mesh.RecalculateNormals();
			mesh.Optimize();
			meshCollider.sharedMesh = null;
			meshCollider.sharedMesh = mesh;
		}
	}
	
	bool IsRightTurn(List<Vector3> points, int a, int b, int c)
	{
		var ab = points[b] - points[a];
		var bc = points[c] - points[b];
		return (ab.x * bc.y - ab.y * bc.x) < 0;
	}
	
	bool IntersectsExistingLines(List<Vector3> points, Vector3 a, Vector3 b)
	{
		for (int i = 0; i < points.Count; i++)
			if (LinesIntersect(points, a, b, points[i], points[(i + 1) % points.Count]))
				return true;
		return false;
	}
	
	bool LinesIntersect(List<Vector3> points, Vector3 point1, Vector3 point2, Vector3 point3, Vector3 point4)
	{
		if (point1 == point3 || point1 == point4 || point2 == point3 || point2 == point4)
			return false;
		
		float ua = (point4.x - point3.x) * (point1.y - point3.y) - (point4.y - point3.y) * (point1.x - point3.x);
		float ub = (point2.x - point1.x) * (point1.y - point3.y) - (point2.y - point1.y) * (point1.x - point3.x);
		float denominator = (point4.y - point3.y) * (point2.x - point1.x) - (point4.x - point3.x) * (point2.y - point1.y);
		
		if (Mathf.Abs(denominator) <= 0.00001f)
		{
			if (Mathf.Abs(ua) <= 0.00001f && Mathf.Abs(ub) <= 0.00001f)
				return true;
		}
		else
		{
			ua /= denominator;
			ub /= denominator;
			
			if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1)
				return true;
		}
		
		return false;
	}
}

public static class Bezier
{
	public static float Curve(float from, float control, float to, float t)
	{
		return from * (1 - t) * (1 - t) + control * 2 * (1 - t) * t + to * t * t;
	}
	public static Vector3 Curve(Vector3 from, Vector3 control, Vector3 to, float t)
	{
		from.x = Curve(from.x, control.x, to.x, t);
		from.y = Curve(from.y, control.y, to.y, t);
		from.z = Curve(from.z, control.z, to.z, t);
		return from;
	}
	
	public static Vector3 Control(Vector3 from, Vector3 to, Vector3 curve)
	{
		//var center = Vector3.Lerp(from, to, 0.5f);
		//return center + (curve - center) * 2;
		var axis = Vector3.Normalize(to - from);
		var dot = Vector3.Dot(axis, curve - from);
		var linePoint = from + axis * dot;
		return linePoint + (curve - linePoint) * 2;
	}
}

public static class Triangulate
{
	public static int[] Points(List<Vector3> points)
	{
		var indices = new List<int>();
		
		int n = points.Count;
		if (n < 3)
			return indices.ToArray();
		
		int[] V = new int[n];
		if (Area(points) > 0)
		{
			for (int v = 0; v < n; v++)
				V[v] = v;
		}
		else
		{
			for (int v = 0; v < n; v++)
				V[v] = (n - 1) - v;
		}
		
		int nv = n;
		int count = 2 * nv;
		for (int m = 0, v = nv - 1; nv > 2; )
		{
			if ((count--) <= 0)
				return indices.ToArray();
			
			int u = v;
			if (nv <= u)
				u = 0;
			v = u + 1;
			if (nv <= v)
				v = 0;
			int w = v + 1;
			if (nv <= w)
				w = 0;
			
			if (Snip(points, u, v, w, nv, V))
			{
				int a, b, c, s, t;
				a = V[u];
				b = V[v];
				c = V[w];
				indices.Add(a);
				indices.Add(b);
				indices.Add(c);
				m++;
				for (s = v, t = v + 1; t < nv; s++, t++)
					V[s] = V[t];
				nv--;
				count = 2 * nv;
			}
		}
		
		indices.Reverse();
		return indices.ToArray();
	}
	
	static float Area(List<Vector3> points)
	{
		int n = points.Count;
		float A = 0.0f;
		for (int p = n - 1, q = 0; q < n; p = q++)
		{
			Vector3 pval = points[p];
			Vector3 qval = points[q];
			A += pval.x * qval.y - qval.x * pval.y;
		}
		return (A * 0.5f);
	}
	
	static bool Snip(List<Vector3> points, int u, int v, int w, int n, int[] V)
    {
		int p;
		Vector3 A = points[V[u]];
		Vector3 B = points[V[v]];
		Vector3 C = points[V[w]];
		if (Mathf.Epsilon > (((B.x - A.x) * (C.y - A.y)) - ((B.y - A.y) * (C.x - A.x))))
			return false;
		for (p = 0; p < n; p++)
		{
			if ((p == u) || (p == v) || (p == w))
				continue;
			Vector3 P = points[V[p]];
			if (InsideTriangle(A, B, C, P))
				return false;
		}
		return true;
	}
	
	static bool InsideTriangle(Vector2 A, Vector2 B, Vector2 C, Vector2 P)
	{
		float ax, ay, bx, by, cx, cy, apx, apy, bpx, bpy, cpx, cpy;
		float cCROSSap, bCROSScp, aCROSSbp;
		
		ax = C.x - B.x; ay = C.y - B.y;
		bx = A.x - C.x; by = A.y - C.y;
		cx = B.x - A.x; cy = B.y - A.y;
		apx = P.x - A.x; apy = P.y - A.y;
		bpx = P.x - B.x; bpy = P.y - B.y;
		cpx = P.x - C.x; cpy = P.y - C.y;
		
		aCROSSbp = ax * bpy - ay * bpx;
		cCROSSap = cx * apy - cy * apx;
		bCROSScp = bx * cpy - by * cpx;
		
		return ((aCROSSbp >= 0.0f) && (bCROSScp >= 0.0f) && (cCROSSap >= 0.0f));
	}
}

PolyMeshEditor.cs

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;
using System.Reflection;

[CustomEditor(typeof(PolyMesh))]
public class PolyMeshEditor : Editor
{
	/// <summary>
	/// Sceneビュー上でのステータスを示す構造体
	/// </summary>
	enum State { Hover, Drag, BoxSelect, DragSelected, RotateSelected, ScaleSelected, Extrude }

	/// <summary>
	/// クリック判定領域
	/// </summary>
	const float clickRadius = 0.12f;

	/// <summary>
	/// ???
	/// </summary>
	FieldInfo undoCallback;
	/// <summary>
	/// Editモードかどうか
	/// </summary>
	bool editing;
	/// <summary>
	/// ???
	/// </summary>
	bool tabDown;
	/// <summary>
	/// ???
	/// </summary>
	State state;

	/// <summary>
	/// 直線パス
	/// </summary>
	List<Vector3> keyPoints;
	/// <summary>
	/// 曲線パス
	/// </summary>
	List<Vector3> curvePoints;
	/// <summary>
	/// カーブするかどうか???
	/// </summary>
	List<bool> isCurve;

	/// <summary>
	/// global座標をlocal座標で持つ???
	/// </summary>
	Matrix4x4 worldToLocal;
	/// <summary>
	/// 回転角度 Quaternionでもつの？？？
	/// </summary>
	Quaternion inverseRotation;
	
	/// <summary>
	/// マウス座標
	/// </sumamry>
	Vector3 mousePosition;
	/// <summary>
	/// クリック座標
	/// </summary>
	Vector3 clickPosition;
	/// <summary>
	/// スクリーン上でのマウスの座標
	/// </summary>
	Vector3 screenMousePosition;
	/// <summary>
	/// マウスカーソルの状態をArrowに指定
	/// </summary>
	MouseCursor mouseCursor = MouseCursor.Arrow;
	/// <summary>
	/// スナップ???
	/// </summary>
	float snap;

	/// <summary>
	/// ???
	/// </summary>
	int dragIndex;
	/// <summary>
	/// ???
	/// </summary>
	List<int> selectedIndices = new List<int>();
	/// <summary>
	/// ???
	/// </summary>
	int nearestLine;
	/// <summary>
	/// ???
	/// </summary>
	Vector3 splitPosition;
	/// <summary>
	/// ???
	/// </summary>
	bool extrudeKeyDown;
	/// <summary>
	/// ???
	/// </summary>
	bool doExtrudeUpdate;
	/// <summary>
	/// ???
	/// </summary>
	bool draggingCurve;

	#region Inspector GUI
	public override void OnInspectorGUI() {
		if (target == null) {
			return;
		}

		if (polyMesh.keyPoints.Count == 0) {
			CreateSquare(polyMesh, 0.5f);
		}

		// Editモードに入るかどうか
		if (editing) {
			if (GUILayout.Button("Stop Editing"))
			{
				editing = false;
				HideWireframe(false);
			}
		}
		else if (GUILayout.Button("Edit PolyMesh")) {
			editing = true;
			HideWireframe(hideWireframe);
		}

		// UV設定
		if (uvSettings = EditorGUILayout.Foldout(uvSettings, "UVs")) {
			var uvPosition = EditorGUILayout.Vector2Field("Position", polyMesh.uvPosition);
			var uvScale = EditorGUILayout.FloatField("Scale", polyMesh.uvScale);
			var uvRotation = EditorGUILayout.Slider("Rotation", polyMesh.uvRotation, -180, 180) % 360;
			if (uvRotation < -180)
				uvRotation += 360;
			if (GUI.changed) {
				RecordUndo();
				polyMesh.uvPosition = uvPosition;
				polyMesh.uvScale = uvScale;
				polyMesh.uvRotation = uvRotation;
			}
			if (GUILayout.Button("Reset UVs")) {
				polyMesh.uvPosition = Vector3.zero;
				polyMesh.uvScale = 1;
				polyMesh.uvRotation = 0;
			}
		}

		// Mesh設定
		if (meshSettings = EditorGUILayout.Foldout(meshSettings, "Mesh")) {
			var curveDetail = EditorGUILayout.Slider("Curve Detail", polyMesh.curveDetail, 0.01f, 1f);
			curveDetail = Mathf.Clamp(curveDetail, 0.01f, 1f);
			if (GUI.changed) {
				RecordUndo();
				polyMesh.curveDetail = curveDetail;
			}

			//Buttons
			EditorGUILayout.BeginHorizontal();
			if (GUILayout.Button("Build Mesh")) {
				polyMesh.BuildMesh();				
			}
			if (GUILayout.Button("Make Mesh Unique")) {
				RecordUndo();
				polyMesh.GetComponent<MeshFilter>().mesh = null;
				polyMesh.BuildMesh();
			}
			EditorGUILayout.EndHorizontal();
		}

		// Colliderの生成
		if (colliderSettings = EditorGUILayout.Foldout(colliderSettings, "Collider")) {
			// Colliderの深さ設定（z軸の長さ）
			var colliderDepth = EditorGUILayout.FloatField("Depth", polyMesh.colliderDepth);
			colliderDepth = Mathf.Max(colliderDepth, 0.01f);
			var buildColliderEdges = EditorGUILayout.Toggle("Build Edges", polyMesh.buildColliderEdges);
			var buildColliderFront = EditorGUILayout.Toggle("Build Font", polyMesh.buildColliderFront);
			if (GUI.changed) {
				RecordUndo();
				polyMesh.colliderDepth = colliderDepth;
				polyMesh.buildColliderEdges = buildColliderEdges;
				polyMesh.buildColliderFront = buildColliderFront;
			}

			// Colliderの破壊
			if (polyMesh.meshCollider == null) {
				if (GUILayout.Button("Create Collider")) {
					RecordDeepUndo();
					var obj = new GameObject("Collider", typeof(MeshCollider));
					polyMesh.meshCollider = obj.GetComponent<MeshCollider>();
					obj.transform.parent = polyMesh.transform;
					obj.transform.localPosition = Vector3.zero;
				}
			} else if (GUILayout.Button("Destroy Collider")) {
				RecordDeepUndo();
				DestroyImmediate(polyMesh.meshCollider.gameObject);
			}
		}

		//Update mesh
		if (GUI.changed) {
			polyMesh.BuildMesh();
		}

		//Editor settings
		if (editorSettings = EditorGUILayout.Foldout(editorSettings, "Editor")) {
			gridSnap = EditorGUILayout.FloatField("Grid Snap", gridSnap);
			autoSnap = EditorGUILayout.Toggle("Auto Snap", autoSnap);
			globalSnap = EditorGUILayout.Toggle("Global Snap", globalSnap);
			EditorGUI.BeginChangeCheck();
			hideWireframe = EditorGUILayout.Toggle("Hide Wireframe", hideWireframe);
			if (EditorGUI.EndChangeCheck()) {
				HideWireframe(hideWireframe);
			}

			editKey = (KeyCode)EditorGUILayout.EnumPopup("[Toggle Edit] Key", editKey);
			selectAllKey = (KeyCode)EditorGUILayout.EnumPopup("[Select All] Key", selectAllKey);
			splitKey = (KeyCode)EditorGUILayout.EnumPopup("[Split] Key", splitKey);
			extrudeKey = (KeyCode)EditorGUILayout.EnumPopup("[Extrude] Key", extrudeKey);
		}
	}
	#endregion

	#region Scene GUI
	void OnSceneGUI() {
		if (target == null) {
			return;
		}

		if (KeyPressed(editKey)) {
			editing = !editing;
		}

		if (editing) {
			// 各種パスを取得
			if (keyPoints == null) {
				keyPoints = new List<Vector3>(polyMesh.keyPoints);
				curvePoints = new List<Vector3>(polyMesh.curvePoints);
				isCurve = new List<bool>(polyMesh.isCurve);
			}

			// Undo時の動作を設定
			if (undoCallback == null) {
				undoCallback = typeof(EditorApplication).GetField("undoRedoPerformed", BindingFlags.NonPublic | BindingFlags.Static);
				if (undoCallback != null) {
					undoCallback.SetValue(null, new EditorApplication.CallbackFunction(OnUndoRedo));
				}
			}

			// ハンドルの座標を読み込む
			Handles.matrix = polyMesh.transform.localToWorldMatrix;

			// パスと線の描画
			DrawAxis();
			Handles.color = Color.white;
			for (int i = 0; i < keyPoints.Count; i++) {
				// PolyMeshの外枠を描画
				Handles.color = nearestLine == i ? Color.green : Color.white;
				DrawSegment(i);
				// 選択中のパスの描画
				if (selectedIndices.Contains(i)) {
					Handles.color = Color.green;
					DrawCircle(keyPoints[i], 0.08f);
				} else {
					Handles.color = Color.white;
				}
				DrawKeyPoint(i);
				// 曲線パスについての描画???
				if (isCurve[i]) {
					Handles.color = (draggingCurve && dragIndex == i) ? Color.white : Color.blue;
					DrawCurvePoint(i);
				}
			}

			// ツール切り替え時はキャンセル
			if (e.type == EventType.KeyDown) {
				switch (e.keyCode) {
				case KeyCode.Q:
				case KeyCode.W:
				case KeyCode.E:
				case KeyCode.R:
					return;
				}
			}

			//パニング中、もしくはカメラがシーン中にない場合はキャンセル
			if (Tools.current == Tool.View || (e.isMouse && e.button > 0) || Camera.current == null || e.type == EventType.ScrollWheel) {
				return;
			}
			//レイアウトの更新時はキャンセル
			if (e.type == EventType.Layout) {
				HandleUtility.AddDefaultControl(GUIUtility.GetControlID(FocusType.Passive));
				return;
			}

			//Cursor rectangle
			EditorGUIUtility.AddCursorRect(new Rect(0, 0, Camera.current.pixelWidth, Camera.current.pixelHeight), mouseCursor);
			mouseCursor = MouseCursor.Arrow;

			//Extrude key state
			if (e.keyCode == extrudeKey) {
				if (extrudeKeyDown) {
					if (e.type == EventType.KeyUp)
						extrudeKeyDown = false;
				} else if (e.type == EventType.KeyDown) {
					extrudeKeyDown = true;
				}
			}

			//Update matrices and snap
			worldToLocal = polyMesh.transform.worldToLocalMatrix;
			inverseRotation = Quaternion.Inverse(polyMesh.transform.rotation) * Camera.current.transform.rotation;
			snap = gridSnap;
			
			//Update mouse position
			screenMousePosition = new Vector3(e.mousePosition.x, Camera.current.pixelHeight - e.mousePosition.y);
			var plane = new Plane(-polyMesh.transform.forward, polyMesh.transform.position);
			var ray = Camera.current.ScreenPointToRay(screenMousePosition);
			float hit;
			if (plane.Raycast(ray, out hit)) {
				mousePosition = worldToLocal.MultiplyPoint(ray.GetPoint(hit));
			} else {
				return;
			}

			//Update nearest line and split position
			nearestLine = NearestLine(out splitPosition);
			
			//Update the state and repaint
			var newState = UpdateState();
			if (state != newState)
				SetState(newState);
			HandleUtility.Repaint();
			e.Use();
		}
	}

	void HideWireframe(bool hide)
	{
        Renderer renderer = polyMesh.GetComponent<Renderer>();
		if (renderer != null) {
			EditorUtility.SetSelectedWireframeHidden(renderer, hide);
		}
	}

	void RecordUndo() {
		Undo.RecordObject(target, "PolyMesh Changed");
	}

	void RecordDeepUndo() {
		Undo.RegisterFullObjectHierarchyUndo(target, "PolyMesh Changed");
	}

	#endregion

	#region State Control

	//Initialize state
	void SetState(State newState) {
		state = newState;
		switch (state) {
		case State.Hover:
			break;
		}
	}

	//Update state
	State UpdateState() {
		switch (state) {
			//Hovering
		case State.Hover:
			DrawNearestLineAndSplit();

			if (Tools.current == Tool.Move && TryDragSelected())
				return State.DragSelected;
			if (Tools.current == Tool.Rotate && TryRotateSelected())
				return State.RotateSelected;
			if (Tools.current == Tool.Scale && TryScaleSelected())
				return State.ScaleSelected;
			if (Tools.current == Tool.Move && TryExtrude())
				return State.Extrude;

			if (TrySelectAll())
				return State.Hover;
			if (TrySplitLine())
				return State.Hover;
			if (TryDeleteSelected())
				return State.Hover;

			if (TryHoverCurvePoint(out dragIndex) && TryDragCurvePoint(dragIndex))
				return State.Drag;
			if (TryHoverKeyPoint(out dragIndex) && TryDragKeyPoint(dragIndex))
				return State.Drag;
			if (TryBoxSelect())
				return State.BoxSelect;

			break;

			//Dragging
		case State.Drag:
			mouseCursor = MouseCursor.MoveArrow;
			DrawCircle(keyPoints[dragIndex], clickRadius);
			if (draggingCurve)
				MoveCurvePoint(dragIndex, mousePosition - clickPosition);
			else
				MoveKeyPoint(dragIndex, mousePosition - clickPosition);
			if (TryStopDrag())
				return State.Hover;
			break;

			//Box Selecting
		case State.BoxSelect:
			if (TryBoxSelectEnd())
				return State.Hover;
			break;

			//Dragging selected
		case State.DragSelected:
			mouseCursor = MouseCursor.MoveArrow;
			MoveSelected(mousePosition - clickPosition);
			if (TryStopDrag())
				return State.Hover;
			break;

			//Rotating selected
		case State.RotateSelected:
			mouseCursor = MouseCursor.RotateArrow;
			RotateSelected();
			if (TryStopDrag())
				return State.Hover;
			break;

			//Scaling selected
		case State.ScaleSelected:
			mouseCursor = MouseCursor.ScaleArrow;
			ScaleSelected();
			if (TryStopDrag())
				return State.Hover;
			break;

			//Extruding
		case State.Extrude:
			mouseCursor = MouseCursor.MoveArrow;
			MoveSelected(mousePosition - clickPosition);
			if (doExtrudeUpdate && mousePosition != clickPosition)
			{
				UpdatePoly(false, false);
				doExtrudeUpdate = false;
			}
			if (TryStopDrag())
				return State.Hover;
			break;
		}
		return state;
	}

	//Update the mesh on undo/redo
	void OnUndoRedo() {
		keyPoints = new List<Vector3>(polyMesh.keyPoints);
		curvePoints = new List<Vector3>(polyMesh.curvePoints);
		isCurve = new List<bool>(polyMesh.isCurve);
		polyMesh.BuildMesh();
	}
	
	void LoadPoly() {
		for (int i = 0; i < keyPoints.Count; i++) {
			keyPoints[i] = polyMesh.keyPoints[i];
			curvePoints[i] = polyMesh.curvePoints[i];
			isCurve[i] = polyMesh.isCurve[i];
		}
	}
	
	void TransformPoly(Matrix4x4 matrix) {
		for (int i = 0; i < keyPoints.Count; i++) {
			keyPoints[i] = matrix.MultiplyPoint(polyMesh.keyPoints[i]);
			curvePoints[i] = matrix.MultiplyPoint(polyMesh.curvePoints[i]);
		}
	}
	
	void UpdatePoly(bool sizeChanged, bool recordUndo) {
		if (recordUndo) {
			RecordUndo();
		}
		if (sizeChanged) {
			polyMesh.keyPoints = new List<Vector3>(keyPoints);
			polyMesh.curvePoints = new List<Vector3>(curvePoints);
			polyMesh.isCurve = new List<bool>(isCurve);
		} else {
			for (int i = 0; i < keyPoints.Count; i++) {
				polyMesh.keyPoints[i] = keyPoints[i];
				polyMesh.curvePoints[i] = curvePoints[i];
				polyMesh.isCurve[i] = isCurve[i];
			}
		}
		for (int i = 0; i < keyPoints.Count; i++){ 
			if (!isCurve[i]) {
				polyMesh.curvePoints[i] = curvePoints[i] = Vector3.Lerp(keyPoints[i], keyPoints[(i + 1) % keyPoints.Count], 0.5f);
			}
		}
		polyMesh.BuildMesh();
	}

	void MoveKeyPoint(int index, Vector3 amount) {
		var moveCurve = selectedIndices.Contains((index + 1) % keyPoints.Count);
		if (doSnap) {
			if (globalSnap) {
				keyPoints[index] = Snap(polyMesh.keyPoints[index] + amount);
				if (moveCurve){
					curvePoints[index] = Snap(polyMesh.curvePoints[index] + amount);
				}
			} else {
				amount = Snap(amount);
				keyPoints[index] = polyMesh.keyPoints[index] + amount;
				if (moveCurve) {
					curvePoints[index] = polyMesh.curvePoints[index] + amount;
				}
			}
		} else {
			keyPoints[index] = polyMesh.keyPoints[index] + amount;
			if (moveCurve) {
				curvePoints[index] = polyMesh.curvePoints[index] + amount;
			}
		}
	}

	void MoveCurvePoint(int index, Vector3 amount) {
		isCurve[index] = true;
		if (doSnap) {
			if (globalSnap){
				curvePoints[index] = Snap(polyMesh.curvePoints[index] + amount);
			} else {
				curvePoints[index] = polyMesh.curvePoints[index] + amount;
			}
		} else {
			curvePoints[index] = polyMesh.curvePoints[index] + amount;
		}
	}

	void MoveSelected(Vector3 amount) {
		foreach (var i in selectedIndices) {
			MoveKeyPoint(i, amount);
		}
	}

	void RotateSelected() {
		var center = GetSelectionCenter();

		Handles.color = Color.white;
		Handles.DrawLine(center, clickPosition);
		Handles.color = Color.green;
		Handles.DrawLine(center, mousePosition);

		var clickOffset = clickPosition - center;
		var mouseOffset = mousePosition - center;
		var clickAngle = Mathf.Atan2(clickOffset.y, clickOffset.x);
		var mouseAngle = Mathf.Atan2(mouseOffset.y, mouseOffset.x);
		var angleOffset = mouseAngle - clickAngle;

		foreach (var i in selectedIndices) {
			var point = polyMesh.keyPoints[i];
			var pointOffset = point - center;
			var a = Mathf.Atan2(pointOffset.y, pointOffset.x) + angleOffset;
			var d = pointOffset.magnitude;
			keyPoints[i] = center + new Vector3(Mathf.Cos(a) * d, Mathf.Sin(a) * d);
		}
	}

	void ScaleSelected() {
		Handles.color = Color.green;
		Handles.DrawLine(clickPosition, mousePosition);

		var center = GetSelectionCenter();
		var scale = mousePosition - clickPosition;

		//Uniform scaling if shift pressed
		if (e.shift) {
			if (Mathf.Abs(scale.x) > Mathf.Abs(scale.y)) {
				scale.y = scale.x;
			} else {
				scale.x = scale.y;
			}
		}

		//Determine direction of scaling
		if (scale.x < 0) {
			scale.x = 1 / (-scale.x + 1);
		}else {
			scale.x = 1 + scale.x;
		}
		if (scale.y < 0) {
			scale.y = 1 / (-scale.y + 1);
		}else {
			scale.y = 1 + scale.y;
		}

		foreach (var i in selectedIndices) {
			var point = polyMesh.keyPoints[i];
			var offset = point - center;
			offset.x *= scale.x;
			offset.y *= scale.y;
			keyPoints[i] = center + offset;
		}
	}

	#endregion

	#region Drawing

	void DrawAxis() {
		Handles.color = Color.red;
		var size = HandleUtility.GetHandleSize(Vector3.zero) * 0.1f;
		Handles.DrawLine(new Vector3(-size, 0), new Vector3(size, 0));
		Handles.DrawLine(new Vector3(0, -size), new Vector2(0, size));
	}

	void DrawKeyPoint(int index) {
		Handles.DotCap(0, keyPoints[index], Quaternion.identity, HandleUtility.GetHandleSize(keyPoints[index]) * 0.03f);
	}

	void DrawCurvePoint(int index) {
		Handles.DotCap(0, curvePoints[index], Quaternion.identity, HandleUtility.GetHandleSize(keyPoints[index]) * 0.03f);
	}

	void DrawSegment(int index) {
		var from = keyPoints[index];
		var to = keyPoints[(index + 1) % keyPoints.Count];
		if (isCurve[index]) {
			var control = Bezier.Control(from, to, curvePoints[index]);
			var count = Mathf.Ceil(1 / polyMesh.curveDetail);
			for (int i = 0; i < count; i++) {
				Handles.DrawLine(Bezier.Curve(from, control, to, i / count), Bezier.Curve(from, control, to, (i + 1) / count));
			}
		} else {
			Handles.DrawLine(from, to);
		}
	}

	void DrawCircle(Vector3 position, float size) {
		Handles.CircleCap(0, position, inverseRotation, HandleUtility.GetHandleSize(position) * size);
	}

	void DrawNearestLineAndSplit() {
		if (nearestLine >= 0) {
			Handles.color = Color.green;
			DrawSegment(nearestLine);
			Handles.color = Color.red;
			Handles.DotCap(0, splitPosition, Quaternion.identity, HandleUtility.GetHandleSize(splitPosition) * 0.03f);
		}
	}

	#endregion

	#region State Checking

	bool TryHoverKeyPoint(out int index) {
		if (TryHover(keyPoints, Color.white, out index)) {
			mouseCursor = MouseCursor.MoveArrow;
			return true;
		}
		return false;
	}

	bool TryHoverCurvePoint(out int index) {
		if (TryHover(curvePoints, Color.white, out index)) {
			mouseCursor = MouseCursor.MoveArrow;
			return true;
		}
		return false;
	}

	bool TryDragKeyPoint(int index) {
		if (TryDrag(keyPoints, index)) {
			draggingCurve = false;
			return true;
		}
		return false;
	}

	bool TryDragCurvePoint(int index) {
		if (TryDrag(curvePoints, index)) {
			draggingCurve = true;
			return true;
		}
		return false;
	}

	bool TryHover(List<Vector3> points, Color color, out int index) {
		if (Tools.current == Tool.Move) {
			index = NearestPoint(points);
			if (index >= 0 && IsHovering(points[index])) {
				Handles.color = color;
				DrawCircle(points[index], clickRadius);
				return true;
			}
		}
		index = -1;
		return false;
	}

	bool TryDrag(List<Vector3> points, int index) {
		if (e.type == EventType.MouseDown && IsHovering(points[index])) {
			clickPosition = mousePosition;
			return true;
		}
		return false;
	}

	bool TryStopDrag() {
		if (e.type == EventType.MouseUp) {
			dragIndex = -1;
			UpdatePoly(false, state != State.Extrude);
			return true;
		}
		return false;
	}

	bool TryBoxSelect() {
		if (e.type == EventType.MouseDown) {
			clickPosition = mousePosition;
			return true;
		}
		return false;
	}

	bool TryBoxSelectEnd() {
		var min = new Vector3(Mathf.Min(clickPosition.x, mousePosition.x), Mathf.Min(clickPosition.y, mousePosition.y));
		var max = new Vector3(Mathf.Max(clickPosition.x, mousePosition.x), Mathf.Max(clickPosition.y, mousePosition.y));
		Handles.color = Color.white;
		Handles.DrawLine(new Vector3(min.x, min.y), new Vector3(max.x, min.y));
		Handles.DrawLine(new Vector3(min.x, max.y), new Vector3(max.x, max.y));
		Handles.DrawLine(new Vector3(min.x, min.y), new Vector3(min.x, max.y));
		Handles.DrawLine(new Vector3(max.x, min.y), new Vector3(max.x, max.y));

		if (e.type == EventType.MouseUp) {
			var rect = new Rect(min.x, min.y, max.x - min.x, max.y - min.y);

			if (!control) { 
				selectedIndices.Clear();
			}
			for (int i = 0; i < keyPoints.Count; i++){
				if (rect.Contains(keyPoints[i])) {
					selectedIndices.Add(i);
				}
			}
			return true;
		}
		return false;
	}

	bool TryDragSelected() {
		if (selectedIndices.Count > 0 && TryDragButton(GetSelectionCenter(), 0.2f)) {
			clickPosition = mousePosition;
			return true;
		}
		return false;
	}

	bool TryRotateSelected() {
		if (selectedIndices.Count > 0 && TryRotateButton(GetSelectionCenter(), 0.3f)) {
			clickPosition = mousePosition;
			return true;
		}
		return false;
	}

	bool TryScaleSelected() {
		if (selectedIndices.Count > 0 && TryScaleButton(GetSelectionCenter(), 0.3f)) {
			clickPosition = mousePosition;
			return true;
		}
		return false;
	}

	bool TryDragButton(Vector3 position, float size) {
		size *= HandleUtility.GetHandleSize(position);
		if (Vector3.Distance(mousePosition, position) < size) {
			if (e.type == EventType.MouseDown) {
				return true;
			} else {
				mouseCursor = MouseCursor.MoveArrow;
				Handles.color = Color.green;
			}
		} else {
			Handles.color = Color.white;
		}
		var buffer = size / 2;
		Handles.DrawLine(new Vector3(position.x - buffer, position.y), new Vector3(position.x + buffer, position.y));
		Handles.DrawLine(new Vector3(position.x, position.y - buffer), new Vector3(position.x, position.y + buffer));
		Handles.RectangleCap(0, position, Quaternion.identity, size);
		return false;
	}

	bool TryRotateButton(Vector3 position, float size) {
		size *= HandleUtility.GetHandleSize(position);
		var dist = Vector3.Distance(mousePosition, position);
		var buffer = size / 4;
		if (dist < size + buffer && dist > size - buffer) {
			if (e.type == EventType.MouseDown) {
				return true;
			}else {
				mouseCursor = MouseCursor.RotateArrow;
				Handles.color = Color.green;
			}
		} else {
			Handles.color = Color.white;
		}
		Handles.CircleCap(0, position, inverseRotation, size - buffer / 2);
		Handles.CircleCap(0, position, inverseRotation, size + buffer / 2);
		return false;
	}

	bool TryScaleButton(Vector3 position, float size) {
		size *= HandleUtility.GetHandleSize(position);
		if (Vector3.Distance(mousePosition, position) < size) {
			if (e.type == EventType.MouseDown) {
				return true;
			}else {
				mouseCursor = MouseCursor.ScaleArrow;
				Handles.color = Color.green;
			}
		}
		else
			Handles.color = Color.white;
		var buffer = size / 4;
		Handles.DrawLine(new Vector3(position.x - size - buffer, position.y), new Vector3(position.x - size + buffer, position.y));
		Handles.DrawLine(new Vector3(position.x + size - buffer, position.y), new Vector3(position.x + size + buffer, position.y));
		Handles.DrawLine(new Vector3(position.x, position.y - size - buffer), new Vector3(position.x, position.y - size + buffer));
		Handles.DrawLine(new Vector3(position.x, position.y + size - buffer), new Vector3(position.x, position.y + size + buffer));
		Handles.RectangleCap(0, position, Quaternion.identity, size);
		return false;
	}

	bool TrySelectAll(){
		if (KeyPressed(selectAllKey)) {
			selectedIndices.Clear();
			for (int i = 0; i < keyPoints.Count; i++){
				selectedIndices.Add(i);
			}
			return true;
		}
		return false;
	}

	bool TrySplitLine() {
		if (nearestLine >= 0 && KeyPressed(splitKey)) {
			if (nearestLine == keyPoints.Count - 1) {
				keyPoints.Add(splitPosition);
				curvePoints.Add(Vector3.zero);
				isCurve.Add(false);
			} else {
				keyPoints.Insert(nearestLine + 1, splitPosition);
				curvePoints.Insert(nearestLine + 1, Vector3.zero);
				isCurve.Insert(nearestLine + 1, false);
			}
			isCurve[nearestLine] = false;
			UpdatePoly(true, true);
			return true;
		}
		return false;
	}

	bool TryExtrude() {
		if (nearestLine >= 0 && extrudeKeyDown && e.type == EventType.MouseDown) {
			var a = nearestLine;
			var b = (nearestLine + 1) % keyPoints.Count;
			if (b == 0 && a == keyPoints.Count - 1) {
				//Extrude between the first and last points
				keyPoints.Add(polyMesh.keyPoints[a]);
				keyPoints.Add(polyMesh.keyPoints[b]);
				curvePoints.Add(Vector3.zero);
				curvePoints.Add(Vector3.zero);
				isCurve.Add(false);
				isCurve.Add(false);
				
				selectedIndices.Clear();
				selectedIndices.Add(keyPoints.Count - 2);
				selectedIndices.Add(keyPoints.Count - 1);
			} else {
				//Extrude between two inner points
				var pointA = keyPoints[a];
				var pointB = keyPoints[b];
				keyPoints.Insert(a + 1, pointA);
				keyPoints.Insert(a + 2, pointB);
				curvePoints.Insert(a + 1, Vector3.zero);
				curvePoints.Insert(a + 2, Vector3.zero);
				isCurve.Insert(a + 1, false);
				isCurve.Insert(a + 2, false);
				
				selectedIndices.Clear();
				selectedIndices.Add(a + 1);
				selectedIndices.Add(a + 2);
			}
			isCurve[nearestLine] = false;

			clickPosition = mousePosition;
			doExtrudeUpdate = true;
			UpdatePoly(true, true);
			return true;
		}
		return false;
	}

	bool TryDeleteSelected() {
		if (KeyPressed(KeyCode.Backspace) || KeyPressed(KeyCode.Delete)) {
			if (selectedIndices.Count > 0) {
				if (keyPoints.Count - selectedIndices.Count >= 3) {
					for (int i = selectedIndices.Count - 1; i >= 0; i--) {
						var index = selectedIndices[i];
						keyPoints.RemoveAt(index);
						curvePoints.RemoveAt(index);
						isCurve.RemoveAt(index);
					}
					selectedIndices.Clear();
					UpdatePoly(true, true);
					return true;
				}
			} else if (IsHovering(curvePoints[nearestLine])) {
				isCurve[nearestLine] = false;
				UpdatePoly(false, true);
			}
		}
		return false;
	}

	bool IsHovering(Vector3 point) {
		return Vector3.Distance(mousePosition, point) < HandleUtility.GetHandleSize(point) * clickRadius;
	}
	
	int NearestPoint(List<Vector3> points) {
		var near = -1;
		var nearDist = float.MaxValue;
		for (int i = 0; i < points.Count; i++) {
			var dist = Vector3.Distance(points[i], mousePosition);
			if (dist < nearDist) {
				nearDist = dist;
				near = i;
			}
		}
		return near;
	}
	
	int NearestLine(out Vector3 position) {
		var near = -1;
		var nearDist = float.MaxValue;
		position = keyPoints[0];
		var linePos = Vector3.zero;
		for (int i = 0; i < keyPoints.Count; i++) {
			var j = (i + 1) % keyPoints.Count;
			var line = keyPoints[j] - keyPoints[i];
			var offset = mousePosition - keyPoints[i];
			var dot = Vector3.Dot(line.normalized, offset);
			if (dot >= 0 && dot <= line.magnitude) {
				if (isCurve[i]) {
					linePos = Bezier.Curve(keyPoints[i], Bezier.Control(keyPoints[i], keyPoints[j], curvePoints[i]), keyPoints[j], dot / line.magnitude);
				} else {
					linePos = keyPoints[i] + line.normalized * dot;
				}
				var dist = Vector3.Distance(linePos, mousePosition);
				if (dist < nearDist) {
					nearDist = dist;
					position = linePos;
					near = i;
				}
			}
		}
		return near;
	}

	bool KeyPressed(KeyCode key) {
		return e.type == EventType.KeyDown && e.keyCode == key;
	}

	bool KeyReleased(KeyCode key) {
		return e.type == EventType.KeyUp && e.keyCode == key;
	}
	
	Vector3 Snap(Vector3 value) {
		value.x = Mathf.Round(value.x / snap) * snap;
		value.y = Mathf.Round(value.y / snap) * snap;
		return value;
	}

	Vector3 GetSelectionCenter() {
		var center = Vector3.zero;
		foreach (var i in selectedIndices)
			center += polyMesh.keyPoints[i];
		return center / selectedIndices.Count;
	}

	#endregion

	#region Properties

	PolyMesh polyMesh {
		get { return (PolyMesh)target; }
	}

	Event e {
		get { return Event.current; }
	}

	bool control {
		get { return Application.platform == RuntimePlatform.OSXEditor ? e.command : e.control; }
	}

	bool doSnap {
		get { return autoSnap ? !control : control; }
	}

	static bool meshSettings {
		get { return EditorPrefs.GetBool("PolyMeshEditor_meshSettings", false); }
		set { EditorPrefs.SetBool("PolyMeshEditor_meshSettings", value); }
	}

	static bool colliderSettings {
		get { return EditorPrefs.GetBool("PolyMeshEditor_colliderSettings", false); }
		set { EditorPrefs.SetBool("PolyMeshEditor_colliderSettings", value); }
	}

	static bool uvSettings {
		get { return EditorPrefs.GetBool("PolyMeshEditor_uvSettings", false); }
		set { EditorPrefs.SetBool("PolyMeshEditor_uvSettings", value); }
	}

	static bool editorSettings {
		get { return EditorPrefs.GetBool("PolyMeshEditor_editorSettings", false); }
		set { EditorPrefs.SetBool("PolyMeshEditor_editorSettings", value); }
	}

	static bool autoSnap {
		get { return EditorPrefs.GetBool("PolyMeshEditor_autoSnap", false); }
		set { EditorPrefs.SetBool("PolyMeshEditor_autoSnap", value); }
	}

	static bool globalSnap {
		get { return EditorPrefs.GetBool("PolyMeshEditor_globalSnap", false); }
		set { EditorPrefs.SetBool("PolyMeshEditor_globalSnap", value); }
	}

	static float gridSnap {
		get { return EditorPrefs.GetFloat("PolyMeshEditor_gridSnap", 1); }
		set { EditorPrefs.SetFloat("PolyMeshEditor_gridSnap", value); }
	}

	static bool hideWireframe {
		get { return EditorPrefs.GetBool("PolyMeshEditor_hideWireframe", true); }
		set { EditorPrefs.SetBool("PolyMeshEditor_hideWireframe", value); }
	}

	public KeyCode editKey {
		get { return (KeyCode)EditorPrefs.GetInt("PolyMeshEditor_editKey", (int)KeyCode.Tab); }
		set { EditorPrefs.SetInt("PolyMeshEditor_editKey", (int)value); }
	}

	public KeyCode selectAllKey {
		get { return (KeyCode)EditorPrefs.GetInt("PolyMeshEditor_selectAllKey", (int)KeyCode.A); }
		set { EditorPrefs.SetInt("PolyMeshEditor_selectAllKey", (int)value); }
	}

	public KeyCode splitKey {
		get { return (KeyCode)EditorPrefs.GetInt("PolyMeshEditor_splitKey", (int)KeyCode.S); }
		set { EditorPrefs.SetInt("PolyMeshEditor_splitKey", (int)value); }
	}

	public KeyCode extrudeKey {
		get { return (KeyCode)EditorPrefs.GetInt("PolyMeshEditor_extrudeKey", (int)KeyCode.D); }
		set { EditorPrefs.SetInt("PolyMeshEditor_extrudeKey", (int)value); }
	}

	#endregion

	#region Menu Items

	[MenuItem("GameObject/Create Other/PolyMesh", false, 1000)]
	static void CreatePolyMesh() {
		var obj = new GameObject("PolyMesh", typeof(MeshFilter), typeof(MeshRenderer));
		var polyMesh = obj.AddComponent<PolyMesh>();
		CreateSquare(polyMesh, 0.5f);
	}

	static void CreateSquare(PolyMesh polyMesh, float size) {
		polyMesh.keyPoints.AddRange(new Vector3[] { new Vector3(size, size), new Vector3(size, -size), new Vector3(-size, -size), new Vector3(-size, size)} );
		polyMesh.curvePoints.AddRange(new Vector3[] { Vector3.zero, Vector3.zero, Vector3.zero, Vector3.zero } );
		polyMesh.isCurve.AddRange(new bool[] { false, false, false, false } );
		polyMesh.BuildMesh();
	}

	#endregion
}