static public int SetControlPoints(IntPtr l)
{
try {
int argc = LuaDLL.lua_gettop(l);
if (matchType(l, argc, 2, typeof(UnityEngine.Vector2[])))
{
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
UnityEngine.Vector2[] a1;
checkType(l, 2, out a1);
self.SetControlPoints(a1);
return(0);
}
else if (matchType(l, argc, 2, typeof(List <UnityEngine.Vector2>)))
{
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
System.Collections.Generic.List <UnityEngine.Vector2> a1;
checkType(l, 2, out a1);
self.SetControlPoints(a1);
return(0);
}
return(error(l, "No matched override function to call"));
}
catch (Exception e) {
return(error(l, e));
}
}
static public int get_DIVISION_THRESHOLD(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
pushValue(l, self.DIVISION_THRESHOLD);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int get_MINIMUM_SQR_DISTANCE(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
pushValue(l, self.MINIMUM_SQR_DISTANCE);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int get_SegmentsPerCurve(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
pushValue(l, self.SegmentsPerCurve);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int constructor(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath o;
o = new UnityEngine.UI.Extensions.BezierPath();
pushValue(l, o);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int GetControlPoints(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
var ret = self.GetControlPoints();
pushValue(l, ret);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_DIVISION_THRESHOLD(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
System.Single v;
checkType(l, 2, out v);
self.DIVISION_THRESHOLD = v;
return(0);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_MINIMUM_SQR_DISTANCE(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
System.Single v;
checkType(l, 2, out v);
self.MINIMUM_SQR_DISTANCE = v;
return(0);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_SegmentsPerCurve(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
System.Int32 v;
checkType(l, 2, out v);
self.SegmentsPerCurve = v;
return(0);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int Interpolate(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
System.Collections.Generic.List <UnityEngine.Vector2> a1;
checkType(l, 2, out a1);
System.Single a2;
checkType(l, 3, out a2);
self.Interpolate(a1, a2);
return(0);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int CalculateBezierPoint(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
System.Single a2;
checkType(l, 3, out a2);
var ret = self.CalculateBezierPoint(a1, a2);
pushValue(l, ret);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int SamplePoints(IntPtr l)
{
try {
UnityEngine.UI.Extensions.BezierPath self = (UnityEngine.UI.Extensions.BezierPath)checkSelf(l);
System.Collections.Generic.List <UnityEngine.Vector2> a1;
checkType(l, 2, out a1);
System.Single a2;
checkType(l, 3, out a2);
System.Single a3;
checkType(l, 4, out a3);
System.Single a4;
checkType(l, 5, out a4);
self.SamplePoints(a1, a2, a3, a4);
return(0);
}
catch (Exception e) {
return(error(l, e));
}
}
private void PopulateMesh(VertexHelper vh, Vector2[] pointsToDraw)
{
//If Bezier is desired, pick the implementation
if (BezierMode != BezierType.None && BezierMode != BezierType.Catenary && pointsToDraw.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();
}
if (BezierMode == BezierType.Catenary && pointsToDraw.Length == 2)
{
CableCurve cable = new CableCurve(pointsToDraw);
cable.slack = Resoloution;
cable.steps = BezierSegmentsPerCurve;
pointsToDraw = cable.Points();
}
if (ImproveResolution != ResolutionMode.None)
{
pointsToDraw = IncreaseResolution(pointsToDraw);
}
// scale based on the size of the rect or use absolute, this is switchable
var sizeX = !relativeSize ? 1 : rectTransform.rect.width;
var sizeY = !relativeSize ? 1 : rectTransform.rect.height;
var offsetX = -rectTransform.pivot.x * sizeX;
var offsetY = -rectTransform.pivot.y * sizeY;
// 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, segments.Count > 1 ? segments[segments.Count - 2] : null));
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]);
}
if (vh.currentVertCount > 64000)
{
Debug.LogError("Max Verticies size is 64000, current mesh vertcies count is [" + vh.currentVertCount + "] - Cannot Draw");
vh.Clear();
return;
}
}
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]);
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
if (m_points != null)
{
Vector2[] array = m_points;
if (BezierMode != 0 && m_points.Length > 3)
{
BezierPath bezierPath = new BezierPath();
bezierPath.SetControlPoints(array);
bezierPath.SegmentsPerCurve = BezierSegmentsPerCurve;
List <Vector2> list;
switch (BezierMode)
{
case BezierType.Basic:
list = bezierPath.GetDrawingPoints0();
break;
case BezierType.Improved:
list = bezierPath.GetDrawingPoints1();
break;
default:
list = bezierPath.GetDrawingPoints2();
break;
}
array = list.ToArray();
}
float num = base.rectTransform.rect.width;
float num2 = base.rectTransform.rect.height;
Vector2 pivot = base.rectTransform.pivot;
float num3 = (0f - pivot.x) * base.rectTransform.rect.width;
Vector2 pivot2 = base.rectTransform.pivot;
float num4 = (0f - pivot2.y) * base.rectTransform.rect.height;
if (!relativeSize)
{
num = 1f;
num2 = 1f;
}
if (UseMargins)
{
num -= Margin.x;
num2 -= Margin.y;
num3 += Margin.x / 2f;
num4 += Margin.y / 2f;
}
vh.Clear();
List <UIVertex[]> list2 = new List <UIVertex[]>();
if (LineList)
{
for (int i = 1; i < array.Length; i += 2)
{
Vector2 vector = array[i - 1];
Vector2 vector2 = array[i];
vector = new Vector2(vector.x * num + num3, vector.y * num2 + num4);
vector2 = new Vector2(vector2.x * num + num3, vector2.y * num2 + num4);
if (LineCaps)
{
list2.Add(CreateLineCap(vector, vector2, SegmentType.Start));
}
list2.Add(CreateLineSegment(vector, vector2, SegmentType.Middle));
if (LineCaps)
{
list2.Add(CreateLineCap(vector, vector2, SegmentType.End));
}
}
}
else
{
for (int j = 1; j < array.Length; j++)
{
Vector2 vector3 = array[j - 1];
Vector2 vector4 = array[j];
vector3 = new Vector2(vector3.x * num + num3, vector3.y * num2 + num4);
vector4 = new Vector2(vector4.x * num + num3, vector4.y * num2 + num4);
if (LineCaps && j == 1)
{
list2.Add(CreateLineCap(vector3, vector4, SegmentType.Start));
}
list2.Add(CreateLineSegment(vector3, vector4, SegmentType.Middle));
if (LineCaps && j == array.Length - 1)
{
list2.Add(CreateLineCap(vector3, vector4, SegmentType.End));
}
}
}
for (int k = 0; k < list2.Count; k++)
{
if (!LineList && k < list2.Count - 1)
{
Vector3 v = list2[k][1].position - list2[k][2].position;
Vector3 v2 = list2[k + 1][2].position - list2[k + 1][1].position;
float num5 = Vector2.Angle(v, v2) * 0.0174532924f;
Vector3 vector5 = Vector3.Cross(v.normalized, v2.normalized);
float num6 = Mathf.Sign(vector5.z);
float num7 = LineThickness / (2f * Mathf.Tan(num5 / 2f));
Vector3 position = list2[k][2].position - v.normalized * num7 * num6;
Vector3 position2 = list2[k][3].position + v.normalized * num7 * num6;
JoinType joinType = LineJoins;
if (joinType == JoinType.Miter)
{
if (num7 < v.magnitude / 2f && num7 < v2.magnitude / 2f && num5 > 0.2617994f)
{
list2[k][2].position = position;
list2[k][3].position = position2;
list2[k + 1][0].position = position2;
list2[k + 1][1].position = position;
}
else
{
joinType = JoinType.Bevel;
}
}
if (joinType == JoinType.Bevel)
{
if (num7 < v.magnitude / 2f && num7 < v2.magnitude / 2f && num5 > 0.5235988f)
{
if (num6 < 0f)
{
list2[k][2].position = position;
list2[k + 1][1].position = position;
}
else
{
list2[k][3].position = position2;
list2[k + 1][0].position = position2;
}
}
UIVertex[] verts = new UIVertex[4]
{
list2[k][2],
list2[k][3],
list2[k + 1][0],
list2[k + 1][1]
};
vh.AddUIVertexQuad(verts);
}
}
vh.AddUIVertexQuad(list2[k]);
}
}
}
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]);
}
}
