296 lines
8.6 KiB
C#
296 lines
8.6 KiB
C#
/// Credit jack.sydorenko, firagon
|
|
/// Sourced from - http://forum.unity3d.com/threads/new-ui-and-line-drawing.253772/
|
|
/// Updated/Refactored from - http://forum.unity3d.com/threads/new-ui-and-line-drawing.253772/#post-2528050
|
|
|
|
using System.Collections.Generic;
|
|
|
|
namespace UnityEngine.UI.Extensions
|
|
{
|
|
[AddComponentMenu("UI/Extensions/Primitives/UILineRenderer")]
|
|
public class UILineRenderer : UIPrimitiveBase
|
|
{
|
|
private enum SegmentType
|
|
{
|
|
Start,
|
|
Middle,
|
|
End,
|
|
}
|
|
|
|
public enum JoinType
|
|
{
|
|
Bevel,
|
|
Miter
|
|
}
|
|
|
|
public enum BezierType
|
|
{
|
|
None,
|
|
Quick,
|
|
Basic,
|
|
Improved,
|
|
}
|
|
|
|
private const float MIN_MITER_JOIN = 15 * Mathf.Deg2Rad;
|
|
|
|
// A bevel 'nice' join displaces the vertices of the line segment instead of simply rendering a
|
|
// quad to connect the endpoints. This improves the look of textured and transparent lines, since
|
|
// there is no overlapping.
|
|
private const float MIN_BEVEL_NICE_JOIN = 30 * Mathf.Deg2Rad;
|
|
|
|
private static readonly Vector2 UV_TOP_LEFT = Vector2.zero;
|
|
private static readonly Vector2 UV_BOTTOM_LEFT = new Vector2(0, 1);
|
|
private static readonly Vector2 UV_TOP_CENTER = new Vector2(0.5f, 0);
|
|
private static readonly Vector2 UV_BOTTOM_CENTER = new Vector2(0.5f, 1);
|
|
private static readonly Vector2 UV_TOP_RIGHT = new Vector2(1, 0);
|
|
private static readonly Vector2 UV_BOTTOM_RIGHT = new Vector2(1, 1);
|
|
|
|
private static readonly Vector2[] startUvs = new[] { UV_TOP_LEFT, UV_BOTTOM_LEFT, UV_BOTTOM_CENTER, UV_TOP_CENTER };
|
|
private static readonly Vector2[] middleUvs = new[] { UV_TOP_CENTER, UV_BOTTOM_CENTER, UV_BOTTOM_CENTER, UV_TOP_CENTER };
|
|
private static readonly Vector2[] endUvs = new[] { UV_TOP_CENTER, UV_BOTTOM_CENTER, UV_BOTTOM_RIGHT, UV_TOP_RIGHT };
|
|
|
|
[SerializeField]
|
|
private Rect m_UVRect = new Rect(0f, 0f, 1f, 1f);
|
|
[SerializeField]
|
|
protected Vector2[] m_points;
|
|
|
|
public float LineThickness = 2;
|
|
public bool UseMargins;
|
|
public Vector2 Margin;
|
|
public bool relativeSize;
|
|
|
|
public bool LineList = false;
|
|
public bool LineCaps = false;
|
|
public JoinType LineJoins = JoinType.Bevel;
|
|
|
|
public BezierType BezierMode = BezierType.None;
|
|
public int BezierSegmentsPerCurve = 10;
|
|
|
|
/// <summary>
|
|
/// UV rectangle used by the texture.
|
|
/// </summary>
|
|
public Rect uvRect
|
|
{
|
|
get
|
|
{
|
|
return m_UVRect;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (m_UVRect == value)
|
|
return;
|
|
m_UVRect = value;
|
|
SetVerticesDirty();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Points to be drawn in the line.
|
|
/// </summary>
|
|
public Vector2[] Points
|
|
{
|
|
get
|
|
{
|
|
return m_points;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (m_points == value)
|
|
return;
|
|
m_points = value;
|
|
SetAllDirty();
|
|
}
|
|
}
|
|
|
|
protected override void OnPopulateMesh(VertexHelper vh)
|
|
{
|
|
if (m_points == null)
|
|
return;
|
|
Vector2[] pointsToDraw = m_points;
|
|
//If Bezier is desired, pick the implementation
|
|
if (BezierMode != BezierType.None && m_points.Length > 3)
|
|
{
|
|
BezierPath bezierPath = new BezierPath();
|
|
|
|
bezierPath.SetControlPoints(pointsToDraw);
|
|
bezierPath.SegmentsPerCurve = BezierSegmentsPerCurve;
|
|
List<Vector2> drawingPoints;
|
|
switch (BezierMode)
|
|
{
|
|
case BezierType.Basic:
|
|
drawingPoints = bezierPath.GetDrawingPoints0();
|
|
break;
|
|
case BezierType.Improved:
|
|
drawingPoints = bezierPath.GetDrawingPoints1();
|
|
break;
|
|
default:
|
|
drawingPoints = bezierPath.GetDrawingPoints2();
|
|
break;
|
|
}
|
|
|
|
pointsToDraw = drawingPoints.ToArray();
|
|
}
|
|
|
|
var sizeX = rectTransform.rect.width;
|
|
var sizeY = rectTransform.rect.height;
|
|
var offsetX = -rectTransform.pivot.x * rectTransform.rect.width;
|
|
var offsetY = -rectTransform.pivot.y * rectTransform.rect.height;
|
|
|
|
// don't want to scale based on the size of the rect, so this is switchable now
|
|
if (!relativeSize)
|
|
{
|
|
sizeX = 1;
|
|
sizeY = 1;
|
|
}
|
|
|
|
if (UseMargins)
|
|
{
|
|
sizeX -= Margin.x;
|
|
sizeY -= Margin.y;
|
|
offsetX += Margin.x / 2f;
|
|
offsetY += Margin.y / 2f;
|
|
}
|
|
|
|
vh.Clear();
|
|
|
|
// Generate the quads that make up the wide line
|
|
var segments = new List<UIVertex[]>();
|
|
if (LineList)
|
|
{
|
|
for (var i = 1; i < pointsToDraw.Length; i += 2)
|
|
{
|
|
var start = pointsToDraw[i - 1];
|
|
var end = pointsToDraw[i];
|
|
start = new Vector2(start.x * sizeX + offsetX, start.y * sizeY + offsetY);
|
|
end = new Vector2(end.x * sizeX + offsetX, end.y * sizeY + offsetY);
|
|
|
|
if (LineCaps)
|
|
{
|
|
segments.Add(CreateLineCap(start, end, SegmentType.Start));
|
|
}
|
|
|
|
segments.Add(CreateLineSegment(start, end, SegmentType.Middle));
|
|
|
|
if (LineCaps)
|
|
{
|
|
segments.Add(CreateLineCap(start, end, SegmentType.End));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (var i = 1; i < pointsToDraw.Length; i++)
|
|
{
|
|
var start = pointsToDraw[i - 1];
|
|
var end = pointsToDraw[i];
|
|
start = new Vector2(start.x * sizeX + offsetX, start.y * sizeY + offsetY);
|
|
end = new Vector2(end.x * sizeX + offsetX, end.y * sizeY + offsetY);
|
|
|
|
if (LineCaps && i == 1)
|
|
{
|
|
segments.Add(CreateLineCap(start, end, SegmentType.Start));
|
|
}
|
|
|
|
segments.Add(CreateLineSegment(start, end, SegmentType.Middle));
|
|
|
|
if (LineCaps && i == pointsToDraw.Length - 1)
|
|
{
|
|
segments.Add(CreateLineCap(start, end, SegmentType.End));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add the line segments to the vertex helper, creating any joins as needed
|
|
for (var i = 0; i < segments.Count; i++)
|
|
{
|
|
if (!LineList && i < segments.Count - 1)
|
|
{
|
|
var vec1 = segments[i][1].position - segments[i][2].position;
|
|
var vec2 = segments[i + 1][2].position - segments[i + 1][1].position;
|
|
var angle = Vector2.Angle(vec1, vec2) * Mathf.Deg2Rad;
|
|
|
|
// Positive sign means the line is turning in a 'clockwise' direction
|
|
var sign = Mathf.Sign(Vector3.Cross(vec1.normalized, vec2.normalized).z);
|
|
|
|
// Calculate the miter point
|
|
var miterDistance = LineThickness / (2 * Mathf.Tan(angle / 2));
|
|
var miterPointA = segments[i][2].position - vec1.normalized * miterDistance * sign;
|
|
var miterPointB = segments[i][3].position + vec1.normalized * miterDistance * sign;
|
|
|
|
var joinType = LineJoins;
|
|
if (joinType == JoinType.Miter)
|
|
{
|
|
// Make sure we can make a miter join without too many artifacts.
|
|
if (miterDistance < vec1.magnitude / 2 && miterDistance < vec2.magnitude / 2 && angle > MIN_MITER_JOIN)
|
|
{
|
|
segments[i][2].position = miterPointA;
|
|
segments[i][3].position = miterPointB;
|
|
segments[i + 1][0].position = miterPointB;
|
|
segments[i + 1][1].position = miterPointA;
|
|
}
|
|
else
|
|
{
|
|
joinType = JoinType.Bevel;
|
|
}
|
|
}
|
|
|
|
if (joinType == JoinType.Bevel)
|
|
{
|
|
if (miterDistance < vec1.magnitude / 2 && miterDistance < vec2.magnitude / 2 && angle > MIN_BEVEL_NICE_JOIN)
|
|
{
|
|
if (sign < 0)
|
|
{
|
|
segments[i][2].position = miterPointA;
|
|
segments[i + 1][1].position = miterPointA;
|
|
}
|
|
else
|
|
{
|
|
segments[i][3].position = miterPointB;
|
|
segments[i + 1][0].position = miterPointB;
|
|
}
|
|
}
|
|
|
|
var join = new UIVertex[] { segments[i][2], segments[i][3], segments[i + 1][0], segments[i + 1][1] };
|
|
vh.AddUIVertexQuad(join);
|
|
}
|
|
}
|
|
|
|
vh.AddUIVertexQuad(segments[i]);
|
|
}
|
|
}
|
|
|
|
private UIVertex[] CreateLineCap(Vector2 start, Vector2 end, SegmentType type)
|
|
{
|
|
if (type == SegmentType.Start)
|
|
{
|
|
var capStart = start - ((end - start).normalized * LineThickness / 2);
|
|
return CreateLineSegment(capStart, start, SegmentType.Start);
|
|
}
|
|
else if (type == SegmentType.End)
|
|
{
|
|
var capEnd = end + ((end - start).normalized * LineThickness / 2);
|
|
return CreateLineSegment(end, capEnd, SegmentType.End);
|
|
}
|
|
|
|
Debug.LogError("Bad SegmentType passed in to CreateLineCap. Must be SegmentType.Start or SegmentType.End");
|
|
return null;
|
|
}
|
|
|
|
private UIVertex[] CreateLineSegment(Vector2 start, Vector2 end, SegmentType type)
|
|
{
|
|
var uvs = middleUvs;
|
|
if (type == SegmentType.Start)
|
|
uvs = startUvs;
|
|
else if (type == SegmentType.End)
|
|
uvs = endUvs;
|
|
|
|
Vector2 offset = new Vector2(start.y - end.y, end.x - start.x).normalized * LineThickness / 2;
|
|
var v1 = start - offset;
|
|
var v2 = start + offset;
|
|
var v3 = end + offset;
|
|
var v4 = end - offset;
|
|
return SetVbo(new[] { v1, v2, v3, v4 }, uvs);
|
|
}
|
|
}
|
|
} |