public PointMover(Transform transform , SpritePoint point)
{
this.transform = transform;
lastPosition = transform.position;
this.point = point;
}
public override void OnInspectorGUI()
{
spriteDeformerAnimation = (SpriteDeformerTargetPoints)target;
base.InspectorSpriteDeformer();
base.drawSelectMaterial();
base.InspectorEditToolBar();
// List<Point> canSelecteAsAnimate = new List<Point>();
if (selectedPoints.Count == 1)
{
SpritePoint sPoint = selectedPoints[0];
SpriteDeformerTargetPoints.PointMover targetMover = spriteDeformerAnimation.getAnimationPoint(sPoint);
Transform targetObject = targetMover != null ? targetMover.transform : null;
Transform newTarget = (Transform)EditorGUILayout.ObjectField("Target object: ", targetObject, typeof(Transform), true);
if (newTarget != targetObject)
{
if (targetObject == null)
{
spriteDeformerAnimation.addMoverPoint(sPoint, newTarget);
}
if (newTarget == null && targetObject != null)
{
spriteDeformerAnimation.pointMovers.Remove(targetMover);
}
if (targetObject != newTarget && targetObject != null)
{
targetMover.transform = newTarget;
}
if (newTarget != null)
{
sPoint.offset = spriteDeformer.getOffsetPointPositionByGlobalPosition(sPoint, newTarget.position);
upDateMeshDate();
}
}
}
}
public override Vector2 getSpritePositionOfSpritePoint(SpritePoint point)
{
point.countOfOfsset = countOfShapes + 1;
Vector2 v2 = point.spritePosition + getPointBlendOffset(point);
return(v2);
}
void Update()
{
if (spriteDeformer == null)
{
return;
}
if (Application.isEditor && !Application.isPlaying)
{
FillPoints();
}
if (points.Count == 0)
{
return;
}
Vector2 rL = Vector2.zero;
for (int i = 0; i < points.Count; i++)
{
SpritePoint p = points[i];
rL += spriteDeformer.SpritePositionToLocal(p.spritePosition + p.offset2d);
}
rL /= (float)points.Count;
rL += localOffset;
Vector3 rG = spriteDeformer.transform.TransformPoint(rL);
rG.z = transform.position.z;
transform.position = rG;
}
/// <summary>
/// Create new edge and add it to list of edges.
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <returns>Created edge</returns>
public Edge CreateEdge(SpritePoint p1, SpritePoint p2)
{
Edge newEdge = new Edge(p1, p2);
_edges.Add(newEdge);
dirty_tris = true;
return(newEdge);
}
public override void doItAfterMovePoints(SpritePoint[] points)
{
foreach (var item in spriteDeformerAnimation.pointMovers)
{
item.transform.position = spriteDeformer.SpritePositionToGlobal(item.point.spritePosition + item.point.offset2d);
Undo.RecordObject(item.transform.gameObject, "Move points");
EditorUtility.SetDirty(item.transform);
}
base.doItAfterMovePoints(points);
}
public override void RemovePoint(SpritePoint p)
{
PointMover pm = getAnimationPoint(p);
if (pm != null)
{
pointMovers.Remove(pm);
}
base.RemovePoint(p);
}
public PointMover getAnimationPoint(SpritePoint p)
{
foreach (var mp in pointMovers)
{
if (mp.point == p)
{
return(mp);
}
}
return(null);
}
/// <summary>
/// Is any edge with this points contains.
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <returns></returns>
public bool ContainsEdge(SpritePoint p1, SpritePoint p2)
{
foreach (Edge e in edges)
{
if (e.point1 == p1 && e.point2 == p2 || e.point1 == p2 && e.point2 == p1)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Get the edge which have this SpritePoints.
/// </summary>
/// <param name="p"></param>
/// <param name="p2"></param>
/// <returns></returns>
public Edge GetEdgeWithTwoPoints(SpritePoint p, SpritePoint p2)
{
foreach (Edge e in edges)
{
if (e.ContainsPoint(p) && e.ContainsPoint(p2))
{
return(e);
}
}
return(null);
}
protected virtual void generateMeshData(bool new_tringulate, bool new_uv, bool new_points, bool new_color, bool new_normals)
{
if (new_points || new_color || new_uv || new_normals)
{
if (new_normals)
{
NewArray <Vector3>(ref mesh_normals, _points.Count);
}
if (new_color)
{
NewArray <Color>(ref mesh_colors, _points.Count);
}
if (new_points)
{
NewArray <Vector3>(ref mesh_vertecs, _points.Count);
}
if (new_uv)
{
NewArray <Vector2>(ref mesh_uvs, _points.Count);
}
//CHanges the sprites position but that is not matched to the actual point position
for (int i = 0; i < _points.Count; i++)
{
SpritePoint cp = _points[i];
// Debug.Log(_points.Count + " points Count");
// Debug.Log(_points[i].spritePosition);
if (new_points)
{
Vector3 v3 = SpritePositionToLocal(getSpritePositionOfSpritePoint(cp));
v3.z = cp.offsets[0].z;
mesh_vertecs[i] = v3;
}
if (new_normals)
{
mesh_normals[i] = Vector3.forward;
}
if (new_color)
{
mesh_colors[i] = cp.color;
}
if (new_uv)
{
mesh_uvs[i] = Vector2.Scale(spriteUVSize, cp.spritePosition) + spriteUVposition;
}
}
}
if (new_tringulate)
{
tringulate();
mesh_triangles = triangulator.intTriangles;
}
}
/// <summary>
/// Remove a point and all edges with this point and set true to dirty_tris, dirty_points, dirty_uv.
/// </summary>
/// <param name="p"></param>
public virtual void RemovePoint(SpritePoint p)
{
SetAllDirty();
List <Edge> delEdges = new List <Edge>();
delEdges.AddRange(GetEdgesWithPoint(p));
foreach (Edge e in delEdges)
{
RemoveEdge(e);
}
_points.Remove(p);
}
///public float[] _blendValues = new float[1];
public override void AddPoint(SpritePoint point, bool autoOffset = false)
{
point.countOfOfsset = countOfShapes;
int index = 0;
if (points.Count > 0)
{
index = points[0].index;
}
point.index = index;
base.AddPoint(point, autoOffset);
}
void FillPoints()
{
points.Clear();
for (int i = 0; i < spriteDeformer.points.Count; i++)
{
SpritePoint sp = spriteDeformer.points[i];
if (sp.name == pointsName)
{
points.Add(sp);
}
}
}
void setColorKeyStart()
{
colorOffset = new ColorOffset[selectedPoints.Count];
for (int i = 0; i < colorOffset.Length; i++)
{
SpritePoint item = selectedPoints[i];
Color32 c = item.color;
if (c.a == 0)
{
c.a += 1;
colorOffset[i].a = -1;
}
else
{
c.a -= 1;
colorOffset[i].a = +1;
}
if (c.r == 0)
{
c.r += 1;
colorOffset[i].r = -1;
}
else
{
c.r -= 1;
colorOffset[i].r = +1;
}
if (c.g == 0)
{
c.g += 1;
colorOffset[i].g = -1;
}
else
{
c.g -= 1;
colorOffset[i].g = +1;
}
if (c.b == 0)
{
c.b += 1;
colorOffset[i].b = -1;
}
else
{
c.b -= 1;
colorOffset[i].b = +1;
}
item.color = c;
}
doItAfterMovePoints(selectedPoints.ToArray());
}
public override void AddPoint(SpritePoint point, bool autoOffset = false)
{
point.countOfOfsset = countOfShapes;
int index = 0;
if (points.Count > 0)
{
index = points[0].index;
}
point.index = index;
base.AddPoint(point, autoOffset);
}
/// <summary>
/// Get all edges what have this SpritePoint.
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public List <Edge> GetEdgesWithPoint(SpritePoint p)
{
List <Edge> edgesp = new List <Edge>();
foreach (Edge e in edges)
{
if (e.ContainsPoint(p))
{
edgesp.Add(e);
}
}
return(edgesp);
}
void calculateLocalPositions()
{
pointsInPivotLocal = new Vector2[spriteDeformerEditor.selectedPoints.Count];
for (int i = 0; i < pointsInPivotLocal.Length; i++)
{
SpritePoint p = spriteDeformerEditor.selectedPoints[i];
Vector2 lp = Vector2.Scale(spriteDeformerEditor.spriteDeformer.SpritePositionToLocal(p.spritePosition + p.offset2d),
spriteDeformerEditor.spriteDeformer.transform.lossyScale) - pivot;
float a = Mathf.Repeat(-oriant, Mathf.PI * 2);
Vector2 newLP;
newLP.x = Mathf.Cos(a) * lp.x - Mathf.Sin(a) * lp.y;
newLP.y = Mathf.Sin(a) * lp.x + Mathf.Cos(a) * lp.y;
pointsInPivotLocal[i] = newLP;
}
}
/// <summary>
/// Add point to topology.
/// </summary>
/// <param name="point"></param>
/// <param name="autoOffset"></param>
public virtual void AddPoint(SpritePoint point, bool autoOffset = false)
{
if (point.id != 0)
{
Debug.LogError("SpritePoint is not unique", this);
return;
}
lastID++;
point.id = lastID;
_points.Add(point);
SetAllDirty();
if (autoOffset)
{
SpritePoint[] tr = GetTriangleAroundPoint(point);
if (tr != null)
{
Vector2 u1 = tr[0].spritePosition; // get the triangle UVs
Vector2 u2 = tr[1].spritePosition; // get the triangle UVs
Vector2 u3 = tr[2].spritePosition; // get the triangle UVs
Vector2 l1 = tr[0].spritePosition + (Vector2)tr[0].offset;
Vector2 l2 = tr[1].spritePosition + (Vector2)tr[1].offset;
Vector2 l3 = tr[2].spritePosition + (Vector2)tr[2].offset;
float a = Medvedya.GeometryMath.Triangle.area(u1, u2, u3); if (a == 0f)
{
return;
}
float a1 = Medvedya.GeometryMath.Triangle.area(u2, u3, point.spritePosition) / a; if (a1 < 0)
{
return;
}
float a2 = Medvedya.GeometryMath.Triangle.area(u3, u1, point.spritePosition) / a; if (a2 < 0)
{
return;
}
float a3 = Medvedya.GeometryMath.Triangle.area(u1, u2, point.spritePosition) / a; if (a3 < 0)
{
return;
}
Vector2 pInObj = a1 * l1 + a2 * l2 + a3 * l3;
point.offset = pInObj - point.spritePosition;
}
}
}
/// <summary>
/// Remove all points and edges and create new topology as rectangle.
/// </summary>
public void SetRectanglePoints()
{
ClearEdges();
ClearPoints();
SpritePoint upLeft = new SpritePoint(0, 1);
SpritePoint downLeft = new SpritePoint(0, 0);
SpritePoint upRight = new SpritePoint(1, 1);
SpritePoint downRight = new SpritePoint(1, 0);
AddPoint(upLeft); AddPoint(downLeft); AddPoint(upRight); AddPoint(downRight);
AddEdge(new Edge(upLeft, upRight));
AddEdge(new Edge(upRight, downRight));
AddEdge(new Edge(downRight, downLeft));
AddEdge(new Edge(downLeft, upLeft));
}
public override void RemovePoint(SpritePoint p)
{
int index = -1;
for (int i = 0; i < 256; i++)
{
if(p == animationPoints[i])
{
index = i;
break;
}
}
if(index != -1)
busyPoints[index] = false;
base.RemovePoint(p);
}
void Start () {
mySprite = gameObject.AddComponent<SpriteDeformerStatic>();
mySprite.sprite = sprite;
mySprite.referenceMaterial = material;
mySprite.SetRectanglePoints();
centerPoint = new SpritePoint(0.5f, 0.5f);
mySprite.AddPoint(centerPoint);
Bounds b = mySprite.bounds;
foreach (var item in mySprite.points)
{
b.Encapsulate((Vector3)mySprite.SpritePositionToLocal(item.spritePosition));
}
mySprite.bounds = b;
mySprite.UpdateMeshImmediate();
}
/// <summary>
/// Generate collider2d
/// </summary>
public void GenerateCollider()
{
NewArray <Vector2[]>(ref colliderRawPaths, borderPaths.Count);
polygonCollider.pathCount = borderPaths.Count;
for (int i = 0; i < borderPaths.Count; i++)
{
PolygonBorderPath colliderPath = borderPaths[i];
NewArray <Vector2>(ref colliderRawPaths[i], colliderPath.points.Length);
for (int j = 0; j < colliderPath.points.Length; j++)
{
SpritePoint currentPoint = _points[colliderPath.points[j]];
colliderRawPaths[i][j] = SpritePositionToLocal(getSpritePositionOfSpritePoint(currentPoint) + currentPoint.colliderOffset);
}
polygonCollider.SetPath(i, colliderRawPaths[i]);
}
}
void setPointsFromPointsInPivotLocal(Vector2 scale, float angle = 0)
{
for (int i = 0; i < pointsInPivotLocal.Length; i++)
{
SpritePoint p = spriteDeformerEditor.selectedPoints[i];
Vector2 lp = Vector2.Scale(pointsInPivotLocal[i], scale);
Vector2 newLP;
newLP.x = Mathf.Cos(oriant + angle) * lp.x - Mathf.Sin(oriant + angle) * lp.y;
newLP.y = Mathf.Sin(oriant + angle) * lp.x + Mathf.Cos(oriant + angle) * lp.y;
newLP += pivot;
Vector2 newLpLocal = new Vector2(
newLP.x / spriteDeformerEditor.spriteDeformer.transform.lossyScale.x,
newLP.y / spriteDeformerEditor.spriteDeformer.transform.lossyScale.y);
p.offset2d = spriteDeformerEditor.spriteDeformer.LocalPositionToSpritePosition(newLpLocal) - p.spritePosition;
spriteDeformerEditor.doItAfterMovePoints(spriteDeformerEditor.selectedPoints.ToArray());
}
}
public List <SpritePoint> GetСonnectedPoint(SpritePoint point, string pointName = "")
{
List <SpritePoint> res = new List <SpritePoint>();
List <Edge> es = GetEdgesWithPoint(point);
foreach (var item in es)
{
if (item.ContainsPoint(point))
{
SpritePoint otherPoint = item.point1 == point ? item.point2 : item.point1;
if (pointName == "" || pointName == otherPoint.name)
{
res.Add(otherPoint);
}
}
}
return(res);
}
public override void RemovePoint(SpritePoint p)
{
int index = -1;
for (int i = 0; i < 256; i++)
{
if (p == animationPoints[i])
{
index = i;
break;
}
}
if (index != -1)
{
busyPoints[index] = false;
}
base.RemovePoint(p);
}
/// <summary>
/// Get the triangle where the point is, it will work only after triangulation was done.
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public SpritePoint[] GetTriangleAroundPoint(SpritePoint point)
{
for (int i = 0; i < mesh_triangles.Length; i += 3)
{
int tr0 = mesh_triangles[i];
int tr1 = mesh_triangles[i + 1];
int tr2 = mesh_triangles[i + 2];
if (
Medvedya.GeometryMath.Triangle.isBelongOriantByClock(
points[tr0].spritePosition,
points[tr1].spritePosition,
points[tr2].spritePosition, point.spritePosition)
)
{
return(new SpritePoint[] { points[tr0], points[tr1], points[tr2] });
}
}
return(null);
}
void createNodes()
{
for (int i = 0; i < spriteDeformer.points.Count; i++)
{
SpritePoint p = spriteDeformer.points[i];
Node newNode = new Node();
newNode.point = p;
newNode.index = i;
newNode.useDeltaPosition = useDeltaPosition;
nodes.Add(newNode);
}
foreach (Edge e in spriteDeformer.edges)
{
int ind1 = spriteDeformer.points.IndexOf(e.point1);
int ind2 = spriteDeformer.points.IndexOf(e.point2);
nodes[ind1].nodes.Add(nodes[ind2]);
nodes[ind2].nodes.Add(nodes[ind1]);
connections.Add(new Connection(nodes[ind1], nodes[ind2]));
}
}
private void sceneColor()
{
Undo.RecordObjects(new Object[] { spriteDeformer }, "Color");
HandleUtility.AddDefaultControl(GUIUtility.GetControlID(GetHashCode(), FocusType.Passive));
if (Tools.current != Tool.View)
{
Tools.current = Tool.None;
}
SpritePoint clossetPoint = null;
float minD = float.MaxValue;
foreach (var p in spriteDeformer.points)
{
Vector2 ps = HandleUtility.WorldToGUIPoint(spriteDeformer.SpritePositionToGlobal(p.offset2d + p.spritePosition));
float d = Vector2.Distance(Event.current.mousePosition, ps);
if (d < minD)
{
minD = d;
clossetPoint = p;
}
}
/*if (clossetPoint != null && Event.current.type == EventType.mouseMove)
* {
* Handles.color = colorSets[ColorSet.LINE_TO_PAINT].standart;
* Handles.color = Color.black;
* Vector3 wPos = spriteDeformer.spritePositionToGlobal(clossetPoint.position + clossetPoint.offset2d);
* Handles.SphereCap(10000,wPos ,Quaternion.identity ,HandleUtility.GetHandleSize(wPos)*50f);
* HandleUtility.Repaint();
*
* } */
if ((Event.current.type == EventType.MouseDown || Event.current.type == EventType.MouseDrag) && clossetPoint != null && Event.current.button == 0 && !Event.current.alt)
{
if (clossetPoint.color != spriteDeformer.editorProps.paintColor)
{
clossetPoint.color = spriteDeformer.editorProps.paintColor;
upDateMeshDate();
doItAfterMovePoints(new SpritePoint[] { clossetPoint });
}
}
}
/// <summary>
/// Divide the edge.
/// </summary>
/// <param name="ed"></param>
/// <param name="autoOffset"></param>
/// <returns></returns>
public SpritePoint DivedeEdge(EdgeDivider ed, bool autoOffset = false)
{
SpritePoint newPoint = new SpritePoint(ed.position);
Edge e1 = new Edge(ed.edge.point1, newPoint);
Edge e2 = new Edge(newPoint, ed.edge.point2);
AddPoint(newPoint);
AddEdge(e1);
AddEdge(e2);
if (autoOffset)
{
float d1 = Vector2.Distance(ed.edge.point1.spritePosition, ed.position);
float d2 = Vector2.Distance(ed.edge.point2.spritePosition, ed.position);
float ds = d1 + d2;
float w1 = d1 / ds;
Vector2 np = Vector2.Lerp(ed.edge.point1.spritePosition + ed.edge.point1.offset2d,
ed.edge.point2.spritePosition + ed.edge.point2.offset2d, w1);
newPoint.offset2d = np - newPoint.spritePosition;
}
RemoveEdge(ed.edge);
return(newPoint);
}
public override void AddPoint(SpritePoint point, bool autoOffset = false)
{
if (base.points.Count >= 256)
{
Debug.Log("You can't have more any than 256 points");
return;
}
base.AddPoint(point, autoOffset);
for (int i = 0; i < 256; i++)
{
if (!busyPoints[i])
{
busyPoints[i] = true;
animationPoints[i] = point;
PointInfo pi;
pi.position = point.spritePosition;
pi.color = point.color;
pi.offset = point.offset;
setValueByIndex(i, pi);
break;
}
}
}
public Vector2 getPointBlendOffset(SpritePoint point)
{
Vector2 newOffsetPos = point.offsets[0];
for (int j = 0; j < countOfShapes; j++)
{
float value = _blendValues[j];
#if UNITY_EDITOR
if (!Application.isPlaying && editorProps.mainToolBar == MainToolBarInspector.EDIT_VERTICS && points.Count > 0)
{
if (j + 1 == points[0].index)
{
value = 1;
}
else
{
value = 0;
}
}
#endif
newOffsetPos += Vector2.Lerp(point.offsets[0], point.offsets[j + 1], value) - (Vector2)point.offsets[0];
}
return(newOffsetPos);
}
public override void AddPoint(SpritePoint point, bool autoOffset = false)
{
if (base.points.Count >= 256)
{
Debug.Log("You can't have more any than 256 points");
return;
}
base.AddPoint(point, autoOffset);
for (int i = 0; i < 256; i++)
{
if (!busyPoints[i])
{
busyPoints[i] = true;
animationPoints[i] = point;
PointInfo pi;
pi.position = point.spritePosition;
pi.color = point.color;
pi.offset = point.offset;
setValueByIndex(i, pi);
break;
}
}
}
public override Vector2 getSpritePositionOfSpritePoint(SpritePoint point)
{
point.countOfOfsset = countOfShapes + 1;
Vector2 v2 = point.spritePosition + getPointBlendOffset(point);
return v2;
}
public PointMover getAnimationPoint(SpritePoint p)
{
foreach (var mp in pointMovers)
{
if (mp.point == p) return mp;
}
return null;
}
/// <summary>
/// Get all edges what have this SpritePoint.
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public List<Edge> GetEdgesWithPoint(SpritePoint p)
{
List<Edge> edgesp = new List<Edge>();
foreach (Edge e in edges)
{
if (e.ContainsPoint(p))
{
edgesp.Add(e);
}
}
return edgesp;
}
/// <summary>
/// Get the edge which have this SpritePoints.
/// </summary>
/// <param name="p"></param>
/// <param name="p2"></param>
/// <returns></returns>
public Edge GetEdgeWithTwoPoints(SpritePoint p, SpritePoint p2)
{
foreach (Edge e in edges)
{
if (e.ContainsPoint(p) && e.ContainsPoint(p2))
{
return e;
}
}
return null;
}
private Vector2 startSelectedRect;//in gui
public virtual void doItAfterMovePoints(SpritePoint[] points)
{
}
public List<SpritePoint> GetСonnectedPoint(SpritePoint point, string pointName = "")
{
List<SpritePoint> res = new List<SpritePoint>();
List<Edge> es = GetEdgesWithPoint(point);
foreach (var item in es)
{
if (item.ContainsPoint(point))
{
SpritePoint otherPoint = item.point1 == point ? item.point2 : item.point1;
if (pointName == "" || pointName == otherPoint.name)
{
res.Add(otherPoint);
}
}
}
return res;
}
public Vector2 getPointBlendOffset(SpritePoint point)
{
Vector2 newOffsetPos = point.offsets[0];
for (int j = 0; j < countOfShapes; j++)
{
float value = _blendValues[j];
#if UNITY_EDITOR
if (!Application.isPlaying && editorProps.mainToolBar == MainToolBarInspector.EDIT_VERTICS && points.Count > 0)
if (j + 1 == points[0].index)
value = 1;
else value = 0;
#else
#endif
newOffsetPos += Vector2.Lerp(point.offsets[0], point.offsets[j + 1], value) - (Vector2)point.offsets[0];
}
return newOffsetPos;
}
/// <summary>
/// Add point to topology.
/// </summary>
/// <param name="point"></param>
/// <param name="autoOffset"></param>
public virtual void AddPoint(SpritePoint point, bool autoOffset = false)
{
_points.Add(point);
SetAllDirty();
if (autoOffset)
{
SpritePoint[] tr = GetTriangleAroundPoint(point);
if (tr != null)
{
Vector2 u1 = tr[0].spritePosition; // get the triangle UVs
Vector2 u2 = tr[1].spritePosition; // get the triangle UVs
Vector2 u3 = tr[2].spritePosition; // get the triangle UVs
Vector2 l1 = tr[0].spritePosition + (Vector2)tr[0].offset;
Vector2 l2 = tr[1].spritePosition + (Vector2)tr[1].offset;
Vector2 l3 = tr[2].spritePosition + (Vector2)tr[2].offset;
float a = Medvedya.GeometryMath.Triangle.area(u1, u2, u3); if (a == 0f) return;
float a1 = Medvedya.GeometryMath.Triangle.area(u2, u3, point.spritePosition) / a; if (a1 < 0) return;
float a2 = Medvedya.GeometryMath.Triangle.area(u3, u1, point.spritePosition) / a; if (a2 < 0) return;
float a3 = Medvedya.GeometryMath.Triangle.area(u1, u2, point.spritePosition) / a; if (a3 < 0) return;
Vector2 pInObj = a1 * l1 + a2 * l2 + a3 * l3;
point.offset = pInObj - point.spritePosition;
}
}
}
public PointMover(Transform transform, SpritePoint point)
{
this.transform = transform;
lastPosition = transform.position;
this.point = point;
}
/// <summary>
/// Remove all points and edges and create new topology as rectangle.
/// </summary>
public void SetRectanglePoints()
{
ClearEdges();
ClearPoints();
SpritePoint upLeft = new SpritePoint(0, 1);
SpritePoint downLeft = new SpritePoint(0, 0);
SpritePoint upRight = new SpritePoint(1, 1);
SpritePoint downRight = new SpritePoint(1, 0);
AddPoint(upLeft); AddPoint(downLeft); AddPoint(upRight); AddPoint(downRight);
AddEdge(new Edge(upLeft, upRight));
AddEdge(new Edge(upRight, downRight));
AddEdge(new Edge(downRight, downLeft));
AddEdge(new Edge(downLeft, upLeft));
}
void drawDragPoint(SpritePoint p)
{
drawDot(p.spritePosition, Color.yellow);
}
/// <summary>
/// Remove points and all edges with this points.
/// </summary>
/// <param name="points"></param>
public void RemovePoints(SpritePoint[] points)
{
foreach (SpritePoint p in points)
{
RemovePoint(p);
}
}
public virtual Vector2 getSpritePositionOfSpritePoint(SpritePoint point)
{
return point.spritePosition + (Vector2)point.offsets[0];
}
/// <summary>
/// Divide the edge.
/// </summary>
/// <param name="ed"></param>
/// <param name="autoOffset"></param>
/// <returns></returns>
public SpritePoint DivedeEdge(EdgeDivider ed, bool autoOffset = false)
{
SpritePoint newPoint = new SpritePoint(ed.position);
Edge e1 = new Edge(ed.edge.point1, newPoint);
Edge e2 = new Edge(newPoint, ed.edge.point2);
AddPoint(newPoint);
AddEdge(e1);
AddEdge(e2);
if (autoOffset)
{
float d1 = Vector2.Distance(ed.edge.point1.spritePosition, ed.position);
float d2 = Vector2.Distance(ed.edge.point2.spritePosition, ed.position);
float ds = d1 + d2;
float w1 = d1 / ds;
Vector2 np = Vector2.Lerp(ed.edge.point1.spritePosition + ed.edge.point1.offset2d,
ed.edge.point2.spritePosition + ed.edge.point2.offset2d, w1);
newPoint.offset2d = np - newPoint.spritePosition;
}
RemoveEdge(ed.edge);
return newPoint;
}
/// <summary>
/// Is any edge with this points contains.
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <returns></returns>
public bool ContainsEdge(SpritePoint p1, SpritePoint p2)
{
foreach (Edge e in edges)
{
if (e.point1 == p1 && e.point2 == p2 || e.point1 == p2 && e.point2 == p1) return true;
}
return false;
}
public override void RemovePoint(SpritePoint p)
{
PointMover pm = getAnimationPoint(p);
if (pm != null)
{
pointMovers.Remove(pm);
}
base.RemovePoint(p);
}
public void addMoverPoint(SpritePoint point, Transform target)
{
PointMover newPointMover = new PointMover(target, point);
pointMovers.Add(newPointMover);
}
public bool ContainsPoint(SpritePoint p)
{
return(p == point1 || p == point2);
}
public Edge(SpritePoint p1, SpritePoint p2)
{
point1 = p1;
point2 = p2;
}
public void addMoverPoint(SpritePoint point , Transform target)
{
PointMover newPointMover = new PointMover(target,point);
pointMovers.Add(newPointMover);
}
public bool ContainsPoint(SpritePoint p)
{
return p == point1 || p == point2;
}
/// <summary>
/// Create new edge and add it to list of edges.
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <returns>Created edge</returns>
public Edge CreateEdge(SpritePoint p1, SpritePoint p2)
{
Edge newEdge = new Edge(p1, p2);
_edges.Add(newEdge);
dirty_tris = true;
return newEdge;
}
public override void doItAfterMovePoints(SpritePoint[] points)
{
foreach (SpritePoint p in points)
{
List<SpritePoint> lps = new List<SpritePoint>();
lps.AddRange(spriteDeformerAnimation.animationPoints);
int index = lps.IndexOf(p);
SpriteDeformerAnimation.PointInfo pi = new SpriteDeformerAnimation.PointInfo();
pi.color = p.color;
pi.position = p.spritePosition;
pi.offset = p.offset;
spriteDeformerAnimation.setValueByIndex(index, pi);
}
base.doItAfterMovePoints(points);
}
/// <summary>
/// Get the triangle where the point is, it will work only after triangulation was done.
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public SpritePoint[] GetTriangleAroundPoint(SpritePoint point)
{
for (int i = 0; i < mesh_triangles.Length; i += 3)
{
int tr0 = mesh_triangles[i];
int tr1 = mesh_triangles[i + 1];
int tr2 = mesh_triangles[i + 2];
if (
Medvedya.GeometryMath.Triangle.isBelongOriantByClock(
points[tr0].spritePosition,
points[tr1].spritePosition,
points[tr2].spritePosition, point.spritePosition)
)
{
return new SpritePoint[] { points[tr0], points[tr1], points[tr2] };
}
}
return null;
}
public Vector2 getOffsetPointPositionByGlobalPosition(SpritePoint point, Vector3 globalPosition)
{
Vector2 newPointPosition = GlobalPositionToSpritePosition(globalPosition);
return newPointPosition - point.spritePosition;
}
/// <summary>
/// Remove a point and all edges with this point and set true to dirty_tris, dirty_points, dirty_uv.
/// </summary>
/// <param name="p"></param>
public virtual void RemovePoint(SpritePoint p)
{
SetAllDirty();
List<Edge> delEdges = new List<Edge>();
delEdges.AddRange(GetEdgesWithPoint(p));
foreach (Edge e in delEdges)
{
RemoveEdge(e);
}
_points.Remove(p);
}
void drawPoint(SpritePoint p)
{
drawDot(p.spritePosition, Color.green);
}
