public static int AddUIVertexQuad(IntPtr l)
{
int result;
try
{
VertexHelper vertexHelper = (VertexHelper)LuaObject.checkSelf(l);
UIVertex[] verts;
LuaObject.checkArray <UIVertex>(l, 2, out verts);
vertexHelper.AddUIVertexQuad(verts);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
protected override void OnPopulateMesh(VertexHelper vh)
{
// This is glue that uses <=5.1 OnFillVBO code with >=5.2 OnPopulatedMesh
// http://docs.unity3d.com/ScriptReference/UI.Graphic.OnPopulateMesh.html
var vbo = new List <UIVertex>();
_OnFillVBO(vbo);
vh.Clear();
var quad = new UIVertex[4];
for (int i = 0; i < vbo.Count; i += 4)
{
vbo.CopyTo(i, quad, 0, 4);
vh.AddUIVertexQuad(quad);
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
base.OnPopulateMesh(vh);
vh.Clear();
int vPos = 0;
foreach (UIVertex v in getVerices())
{
mTmpVerts[vPos++] = v;
if (vPos == 4)
{
UIVertex tmp = mTmpVerts[2];
mTmpVerts[2] = mTmpVerts[3];
mTmpVerts[3] = tmp;
vPos = 0;
vh.AddUIVertexQuad(mTmpVerts);
}
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
vh.Clear();
//在这里可以做一个数据判断，如果数据一样 就不再刷新
if (_meshInfo != null)
{
for (int i = 0; i < _meshInfo.Vertices.Count; i++)
{
int tempVertsIndex = i & 3;
_tempVerts[tempVertsIndex].position = _meshInfo.Vertices[i]; // Utility.TransformWorld2Point(transform, _meshInfo.Vertices[i]);
_tempVerts[tempVertsIndex].uv0 = _meshInfo.UVs[i];
_tempVerts[tempVertsIndex].color = color;
if (tempVertsIndex == 3)
{
vh.AddUIVertexQuad(_tempVerts);
}
}
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
vh.Clear();
if (Points.Length < 2)
{
return;
}
Vector2 prevTop = points[0];
Vector2 prevBottom = new Vector2(points[0].x, 0f);
float maxX = 0f;
float maxY = 0f;
foreach (Vector2 point in points)
{
if (point.x > maxX)
{
maxX = point.x;
}
if (point.y > maxY)
{
maxY = point.y;
}
}
for (int i = 1; i < Points.Length; i++)
{
Vector2 currentTop = points[i];
Vector2 currentBottom = new Vector2(points[i].x, 0f);
vh.AddUIVertexQuad(CreateUIVertices(
new[] { prevBottom, prevTop, currentTop, currentBottom },
new[] { GetCorrectUV(prevBottom, maxX, maxY),
GetCorrectUV(prevTop, maxX, maxY),
GetCorrectUV(currentTop, maxX, maxY),
GetCorrectUV(currentBottom, maxX, maxY) }));
prevTop = currentTop;
prevBottom = currentBottom;
}
}
public static void DrawLine(VertexHelper vh, Vector3 p1, Vector3 p2, float size, Color32 color)
{
if (p1 == p2)
{
return;
}
Vector3 v = Vector3.Cross(p2 - p1, Vector3.forward).normalized *size;
vertex[0].position = p1 - v;
vertex[1].position = p2 - v;
vertex[2].position = p2 + v;
vertex[3].position = p1 + v;
for (int j = 0; j < 4; j++)
{
vertex[j].color = color;
vertex[j].uv0 = Vector2.zero;
}
vh.AddUIVertexQuad(vertex);
}
//添加下划线
private void AddUnderlineQuad(IList <UIVertex> underlineVerts, Vector3 startBoxPos, Vector3 endBoxPos)
{
Vector3[] underlinePos = new Vector3[4];
underlinePos[0] = startBoxPos + new Vector3(0, fontSize * -0.1f, 0);
underlinePos[1] = endBoxPos + new Vector3(0, fontSize * -0.1f, 0);;
underlinePos[2] = endBoxPos + new Vector3(0, fontSize * 0f, 0);
underlinePos[3] = startBoxPos + new Vector3(0, fontSize * 0f, 0);
for (int i = 0; i < 4; ++i)
{
int tempVertsIndex = i & 3;
m_TempVerts[tempVertsIndex] = underlineVerts[i % 4];
m_TempVerts[tempVertsIndex].color = Color.blue;
m_TempVerts[tempVertsIndex].position = underlinePos[i];
if (tempVertsIndex == 3)
{
mVertexHelperRef.AddUIVertexQuad(m_TempVerts);
}
}
}
protected void DrawRectang(VertexHelper vh, Vector2 point1st, Vector2 point2nd, Vector2 point3rd, Vector2 point4th, Color color)
{
UIVertex[] verts = new UIVertex[4];
verts[0].position = point1st;
verts[0].color = color;
verts[0].uv0 = Vector2.zero;
verts[1].position = point2nd;
verts[1].color = color;
verts[1].uv0 = Vector2.zero;
verts[2].position = point3rd;
verts[2].color = color;
verts[2].uv0 = Vector2.zero;
verts[3].position = point4th;
verts[3].color = color;
verts[3].uv0 = Vector2.zero;
vh.AddUIVertexQuad(verts);
}
private void DrawRect(VertexHelper vh, Vector2 min, Vector2 max, Color color)
{
// We assume that pivot is bottom left for us, to ease our calculations
RectTransform rc = this.transform as RectTransform;
Vector2 start = new Vector2(min.x * rc.rect.width, min.y * rc.rect.height);
Vector2 end = new Vector2(max.x * rc.rect.width, max.y * rc.rect.height);
Vector2 pos0 = new Vector2(start.x, start.y);
Vector2 pos1 = new Vector2(start.x, end.y);
Vector2 pos2 = new Vector2(end.x, end.y);
Vector2 pos3 = new Vector2(end.x, start.y);
Vector2 pos4 = new Vector2(start.x, start.y);
// Draw the rectangle
vh.AddUIVertexQuad(SetVbo(new[] { pos0, pos1, pos2, pos3, pos4 }, new[] { uv0, uv1, uv2, uv3, uv4 }, 5, color));
}
public override void AddQuad(UIVertex vLeftTop, UIVertex vRightTop, UIVertex vLeftBottom, UIVertex vRightBottom)
{
if (mListWrapAround != null)
{
mListWrapAround.Add(vLeftTop);
mListWrapAround.Add(vRightTop);
mListWrapAround.Add(vRightBottom);
mListWrapAround.Add(vLeftBottom);
return;
}
if (mVHWrapAround != null)
{
mTmpQuad[0] = vLeftTop;
mTmpQuad[1] = vRightTop;
mTmpQuad[2] = vRightBottom;
mTmpQuad[3] = vLeftBottom;
mVHWrapAround.AddUIVertexQuad(mTmpQuad);
}
}
/// <summary>
/// OnPopulateMesh.
/// </summary>
protected override void OnPopulateMesh(VertexHelper vh)
{
vh.Clear();
float outer = -mRadius;
float inner = outer + mThickness;
Vector2 prevPos1 = Vector2.zero;
Vector2 prevPos2 = Vector2.zero;
int segment = (int)(3.6f * mDensity) + 1;
for (int i = 0; i <= segment; i++)
{
float degrees = Mathf.Clamp(i * 100f / mDensity, 0, mDegrees);
float rad = Mathf.Deg2Rad * (270 - degrees - mRotation);
float cos = Mathf.Cos(rad);
float sin = Mathf.Sin(rad);
Vector2 pos0 = prevPos1;
Vector2 pos1 = new Vector2(outer * cos, outer * sin);
Vector2 pos2 = mIsFill ? Vector2.zero : new Vector2(inner * cos, inner * sin);
Vector2 pos3 = mIsFill ? Vector2.zero : prevPos2;
prevPos1 = pos1;
prevPos2 = pos2;
Vector2 uv0 = new Vector2(0, 1);
Vector2 uv1 = new Vector2(1, 1);
Vector2 uv2 = new Vector2(1, 0);
Vector2 uv3 = new Vector2(0, 0);
vh.AddUIVertexQuad(_GetVBOs(new Vector2[] { pos0, pos1, pos2, pos3 }, new Vector2[] { uv0, uv1, uv2, uv3 }));
if (degrees >= mDegrees)
{
break;
}
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
float outer = -rectTransform.pivot.x * rectTransform.rect.width;
float inner = -rectTransform.pivot.x * rectTransform.rect.width + this.thickness;
vh.Clear();
Vector2 prevX = Vector2.zero;
Vector2 prevY = Vector2.zero;
Vector2 uv0 = new Vector2(0, 0);
Vector2 uv1 = new Vector2(0, 1);
Vector2 uv2 = new Vector2(1, 1);
Vector2 uv3 = new Vector2(1, 0);
Vector2 pos0;
Vector2 pos1;
Vector2 pos2;
Vector2 pos3;
float tw = rectTransform.rect.width;
float th = rectTransform.rect.height;
float angleByStep = (FILL_PERCENT / 100f * (Mathf.PI * 2f)) / segments;
float currentAngle = 0f;
for (int i = 0; i < segments + 1; i++)
{
float c = Mathf.Cos(currentAngle);
float s = Mathf.Sin(currentAngle);
StepThroughPointsAndFill(outer, inner, ref prevX, ref prevY, out pos0, out pos1, out pos2, out pos3, c, s);
uv0 = new Vector2(pos0.x / tw + 0.5f, pos0.y / th + 0.5f);
uv1 = new Vector2(pos1.x / tw + 0.5f, pos1.y / th + 0.5f);
uv2 = new Vector2(pos2.x / tw + 0.5f, pos2.y / th + 0.5f);
uv3 = new Vector2(pos3.x / tw + 0.5f, pos3.y / th + 0.5f);
vh.AddUIVertexQuad(SetVbo(new[] { pos0, pos1, pos2, pos3 }, new[] { uv0, uv1, uv2, uv3 }));
currentAngle += angleByStep;
}
}
protected override void OnPopulateMesh(VertexHelper _VertexHelper)
{
_VertexHelper.Clear();
if (Characters == null)
{
return;
}
foreach (BitmapCharacter character in Characters)
{
if (character == null || !character.Enabled || !character.Visible)
{
continue;
}
character.Fill(ref m_Buffer);
_VertexHelper.AddUIVertexQuad(m_Buffer);
}
}
/// <summary>
/// 添加下划线
/// </summary>
/// <param name="toFill">模型</param>
/// <param name="vertexs">顶点</param>
/// <param name="starPos">开始坐标</param>
/// <param name="endPos">结束坐标</param>
void AddUnderlineQuad(VertexHelper toFill, IList <UIVertex> vertexs, Vector3 starPos, Vector3 endPos, Color32 color)
{
//厚度 0.1f * fontSize
_underlinePos[0] = new Vector3(starPos.x, starPos.y - 1f, 0);;
_underlinePos[1] = new Vector3(endPos.x, starPos.y - 1f, 0);;
_underlinePos[2] = new Vector3(endPos.x, starPos.y + fontSize * -0.15f - 1f, 0);
_underlinePos[3] = new Vector3(starPos.x, starPos.y + fontSize * -0.15f - 1f, 0);
for (int i = 0; i < 4; ++i)
{
int tempVertsIndex = i & 3;
m_TempVerts[tempVertsIndex] = vertexs[i % 4];
m_TempVerts[tempVertsIndex].color = color;
m_TempVerts[tempVertsIndex].position = _underlinePos[i];
if (tempVertsIndex == 3)
{
toFill.AddUIVertexQuad(m_TempVerts);
}
}
}
private void AddUIVertexQuad(VertexHelper vh, ref float xMin, float xMax, float yMin, float yMax, Color left, Color right, CharacterInfo underline)
{
s_TempUIVertexs[0] = new UIVertex()
{
position = new Vector3(xMin, yMin), color = left, uv0 = underline.uvTopLeft
};
s_TempUIVertexs[1] = new UIVertex()
{
position = new Vector3(xMax, yMin), color = right, uv0 = underline.uvTopRight
};
s_TempUIVertexs[2] = new UIVertex()
{
position = new Vector3(xMax, yMax), color = right, uv0 = underline.uvBottomRight
};
s_TempUIVertexs[3] = new UIVertex()
{
position = new Vector3(xMin, yMax), color = left, uv0 = underline.uvBottomLeft
};
vh.AddUIVertexQuad(s_TempUIVertexs);
xMin = xMax;
}
protected override void OnPopulateMesh(VertexHelper toFill)
{
if (font == null)
{
return;
}
int maxHeight = GetMaxHeight();;
Rect rect = rectTransform.rect;
Vector2 anchor = Anchor();
Vector2 refPoint = Vector2.zero;
refPoint.x = (anchor.x == 1 ? rect.xMax : rect.xMin);
refPoint.y = (anchor.y == 0 ? rect.yMin : rect.yMax);
Vector2 roundingOffset = PixelAdjustPoint(refPoint) - refPoint;
IList <UIVertex> verts = CreateVertices(rect, anchor, maxHeight);
int vertCount = verts.Count;
UIVertex[] tempVerts = new UIVertex[4];
// float unitsPerPixel = 1 / pixelsPerUnit;
toFill.Clear();
for (int i = 0; i < vertCount; ++i)
{
int tempVertsIndex = i & 3;
tempVerts[tempVertsIndex] = verts[i];
// tempVerts[tempVertsIndex].position *= unitsPerPixel;
if (roundingOffset != Vector2.zero)
{
tempVerts[tempVertsIndex].position.x += roundingOffset.x;
tempVerts[tempVertsIndex].position.y -= roundingOffset.y;
}
if (tempVertsIndex == 3)
{
toFill.AddUIVertexQuad(tempVerts);
}
}
}
public void PopulateMesh(VertexHelper toFill)
{
Vector3 vec_00 = rectTransform.anchoredPosition;
Vector3 vec_01 = rectTransform.anchoredPosition + new Vector2(0, rectTransform.sizeDelta.y);
Vector3 vec_11 = rectTransform.anchoredPosition + new Vector2(Mathf.Lerp(0f, rectTransform.sizeDelta.x, time / timeMax), rectTransform.sizeDelta.y);
Vector3 vec_10 = rectTransform.anchoredPosition + new Vector2(Mathf.Lerp(0f, rectTransform.sizeDelta.x, time / timeMax), 0);
toFill.AddUIVertexQuad(new UIVertex[] {
new UIVertex {
position = vec_00, color = Color.green
},
new UIVertex {
position = vec_01, color = Color.green
},
new UIVertex {
position = vec_11, color = Color.green
},
new UIVertex {
position = vec_10, color = Color.green
},
});
}
void AddUnderlineQuad(VertexHelper _VToFill, IList <UIVertex> _VTUT, Vector3 _VStartPos, Vector3 _VEndPos)
{
Vector3[] _TUnderlinePos = new Vector3[4];
_TUnderlinePos[0] = _VStartPos;
_TUnderlinePos[1] = _VEndPos;
_TUnderlinePos[2] = _VEndPos + new Vector3(0, fontSize * 0.2f, 0);
_TUnderlinePos[3] = _VStartPos + new Vector3(0, fontSize * 0.2f, 0);
for (int i = 0; i < 4; ++i)
{
int tempVertsIndex = i & 3;
m_TempVerts[tempVertsIndex] = _VTUT[i % 4];
m_TempVerts[tempVertsIndex].color = Color.blue;
m_TempVerts[tempVertsIndex].position = _TUnderlinePos[i];
if (tempVertsIndex == 3)
{
_VToFill.AddUIVertexQuad(m_TempVerts);
}
}
}
public override void ModifyMesh(VertexHelper toFill)
{
if (!IsActive())
{
return;
}
if (m_NumberOfLetters == -1)
{
return;
}
int vertCount = toFill.currentVertCount;
for (int i = 0; i < vertCount; i++)
{
if (tmpVertices.Count < (i + 1))
{
tmpVertices.Add(new UIVertex());
}
UIVertex vert = tmpVertices[i];
toFill.PopulateUIVertex(ref vert, i);
tmpVertices[i] = vert;
}
int numberOfVertices = m_NumberOfLetters * 4;
toFill.Clear();
for (int i = 0; i < numberOfVertices && i < tmpVertices.Count; i++)
{
int tempVertsIndex = i & 3;
tmpVerticesQuad[tempVertsIndex] = tmpVertices[i];
if (tempVertsIndex == 3)
{
toFill.AddUIVertexQuad(tmpVerticesQuad);
}
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
vh.Clear();
UIVertex[] verts = new UIVertex[4];
verts[0].position = new Vector3(leftTran.localPosition.x, -height / 2);
verts[0].color = color;
verts[0].uv0 = Vector2.zero;
verts[1].position = new Vector3(leftTran.localPosition.x, height / 2);
verts[1].color = color;
verts[1].uv0 = Vector2.zero;
verts[2].position = new Vector3(rightTran.localPosition.x, height / 2);
verts[2].color = color;
verts[2].uv0 = Vector2.zero;
verts[3].position = new Vector3(rightTran.localPosition.x, -height / 2);
verts[3].color = color;
verts[3].uv0 = Vector2.zero;
vh.AddUIVertexQuad(verts);
}
protected override void OnPopulateMesh(VertexHelper vh)
{
if ((base.get_font() != null) && !this.TextGenerator.IsRequestingCharactersInTexture)
{
if (!this.isDirtyVerts)
{
this.TextGenerator.IsRebuidFont = true;
}
IList <UIVertex> list = this.TextGenerator.CreateVertex();
vh.Clear();
for (int i = 0; i < list.Count; i++)
{
int index = i & 3;
this.m_TempVerts[index] = list[i];
if (index == 3)
{
vh.AddUIVertexQuad(this.m_TempVerts);
}
}
this.isDirtyVerts = false;
}
}
public static void DrawLine(this VertexHelper vh, IList <Vector2> points, float thickness, Color color)
{
for (var i = 1; i < points.Count; i++)
{
var prev = points[i - 1];
var curr = points[i];
var angle = Mathf.Atan2(curr.y - prev.y, curr.x - prev.x) * Mathf.Rad2Deg;
var v1 = prev + new Vector2(0, -thickness / 2);
var v2 = prev + new Vector2(0, +thickness / 2);
var v3 = curr + new Vector2(0, +thickness / 2);
var v4 = curr + new Vector2(0, -thickness / 2);
v1 = RotatePointAroundPivot(v1, prev, angle);
v2 = RotatePointAroundPivot(v2, prev, angle);
v3 = RotatePointAroundPivot(v3, curr, angle);
v4 = RotatePointAroundPivot(v4, curr, angle);
vh.AddUIVertexQuad(CreateVBO(color, v1, v2, v3, v4));
// vh.AddUIVertexQuad(CreateVBO(new Color(Random.Range(0, 1), Random.Range(0, 1f), Random.Range(0, 1)), new[] { v1, v2, v3, v4 }));
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
//todo Debug.Log("刷新显示");
CurColor = color0;
vh.Clear();
Vector2 size = this.GetPixelAdjustedRect().size;
float xPerCell = size.x / yCount;
float yPerCell = size.y / xCount;
perLenght = xPerCell;
if (yPerCell < xPerCell)
{
perLenght = yPerCell;
}
// calc lefttop start point
origin = new Vector2(-yCount / 2.0f * perLenght, xCount / 2.0f * perLenght);
for (int y = 0; y < xCount; y++)
{
var index = CurColor;
for (int x = 0; x < yCount; x++)
{
var leftTop = origin + new Vector3(x * perLenght, -y * perLenght, 0);
var rightTop = origin + new Vector3((x + 1) * perLenght, -y * perLenght, 0);
var rightBottom = origin + new Vector3((x + 1) * perLenght, -(y + 1) * perLenght, 0);
var leftBottom = origin + new Vector3(x * perLenght, -(y + 1) * perLenght, 0);
Color col = CurColor;
vh.AddUIVertexQuad(new UIVertex[]
{
GetUIVertex(leftTop, col),
GetUIVertex(rightTop, col),
GetUIVertex(rightBottom, col),
GetUIVertex(leftBottom, col)
});
}
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
vh.Clear();
if (Points.Length < 2)
{
return;
}
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;
var sizeVector = new Vector2(sizeX, sizeY);
var offsetVector = new Vector2(offsetX, offsetY);
for (var i = 0; i < Points.Length - 1; i++)
{
var current = new Vector2(Points[i].x * sizeVector.x, Points[i].y * sizeVector.y) + offsetVector;
var next = new Vector2(Points[i + 1].x * sizeVector.x, Points[i + 1].y * sizeVector.y) + offsetVector;
var line = next - current;
var normalized = line.normalized;
var up = normalized.Rotate(-90) * LineThickness / 2;
var vertices = new Vector2[4];
vertices[0] = current + up;
vertices[1] = next + up;
vertices[2] = next - up;
vertices[3] = current - up;
var uvs = new Vector2[4] {
Vector2.zero, new Vector2(1, 0), Vector2.one, new Vector2(0, 1)
};
vh.AddUIVertexQuad(CreateUIVertexQuad(vertices, uvs));
}
}
private void DrawHorizontal(VertexHelper vh)
{
float halfWidth = Setting.BarWidth / 2.0f;
Vector2 leftStart = origin + new Vector2(0, Setting.BarSpacing / 2.0f);
foreach (var bars in Data.BarDic)
{
foreach (var bar in bars.Value)
{
Vector2 startPos = leftStart + new Vector2(0, halfWidth);
for (int m = 0; m < bar.bars.Count; m++)
{
Color barColor = BarColor(m);
float height = bar.bars[m].value * size.x;
Vector2 endPos = startPos + new Vector2(height, 0);
vh.AddUIVertexQuad(GetQuad(startPos, endPos, barColor, Setting.BarWidth));
startPos = startPos + new Vector2(0, Setting.BarInterval + Setting.BarWidth);
}
leftStart = leftStart + new Vector2(0, Setting.BarSpacing) + new Vector2(0, Setting.BarWidth * bar.bars.Count)
+ new Vector2(0, Setting.BarInterval * (bar.bars.Count - 1));
}
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
vh.Clear();
var perRadian = Mathf.PI * 2 / m_smoothDegree;
var outRadius = m_radius + m_loopWidth;
for (int i = 0; i < m_smoothDegree; i++)
{
var startRadian = perRadian * i;
var endRadian = perRadian * (i + 1);
var outStartPos = new Vector2(Mathf.Cos(startRadian), Mathf.Sin(startRadian)) * outRadius;
var inStartPos = new Vector2(Mathf.Cos(startRadian), Mathf.Sin(startRadian)) * m_radius;
var outEndPos = new Vector2(Mathf.Cos(endRadian), Mathf.Sin(endRadian)) * outRadius;
var inEndPos = new Vector2(Mathf.Cos(endRadian), Mathf.Sin(endRadian)) * m_radius;
vh.AddUIVertexQuad(new UIVertex[]
{
GetUIVertex(outStartPos, Color.black),
GetUIVertex(inStartPos, Color.black),
GetUIVertex(inEndPos, Color.black),
GetUIVertex(outEndPos, Color.black)
});
}
}
public static GameObject CreateUnityWater(this WaterFile water)
{
using (var helper = new VertexHelper()) {
foreach (var plane in water.Planes)
{
var p1 = new UIVertex {
position = plane.P1
};
var p2 = new UIVertex {
position = plane.P2
};
var p3 = new UIVertex {
position = plane.P3
};
var p4 = new UIVertex {
position = plane.P4
};
helper.AddUIVertexQuad(new UIVertex[] { p1, p2, p3, p4 });
}
var go = new GameObject("Water");
var mesh = new Mesh();
helper.FillMesh(mesh);
mesh.name = "Water";
mesh.RecalculateNormals();
mesh.RecalculateBounds();
go.AddComponent <MeshRenderer>().material = ResourcesHelper.WaterMaterial;
go.AddComponent <MeshFilter>().sharedMesh = mesh;
go.layer = LayerMask.NameToLayer("Water");
return(go);
}
}
/// <summary>
/// Gets the quad dottedline.
/// </summary>
/// <returns>The quad dottedline.</returns>
/// <param name="vh"></param>
/// <param name="startpos">Startpos.</param>
/// <param name="endPos">End position.</param>
/// <param name="color0">Color0.</param>
/// <param name="lineWidth">Line width.</param>
public virtual VertexHelper GetQuadDottedline(VertexHelper vh, Vector2 startpos, Vector2 endPos, Color color0, float lineWidth = 2.0f)
{
Vector2 dir = (endPos - startpos).normalized;
float lenght = Vector3.Distance(startpos, endPos);
float perLenght = 7;
float perSpace = 2;
for (float total = 0; total < lenght; total += perLenght + perSpace)
{
float addLenght = perLenght;
if (total + perSpace >= lenght)
{
return(vh);
}
if (total + perSpace + perLenght >= lenght)
{
addLenght = lenght - total;
}
Vector2 tempEnd = startpos + dir * addLenght;
vh.AddUIVertexQuad(GetQuad(startpos, tempEnd, color0, lineWidth));
startpos = tempEnd + dir * perSpace;
}
return(vh);
}
private void AddUIVertexQuad(VertexHelper toFill, float unitsPerPixel)
{
toFill.Clear();
var verts = cachedTextGenerator.verts;
UIVertex[] verTemp = new UIVertex[4];
Vector2 offset = new Vector2(verts[0].position.x, verts[0].position.y) * unitsPerPixel;
offset = PixelAdjustPoint(offset) - offset;
bool needOffset = offset != Vector2.zero;
int index = 0;
for (int i = 0; i < _filterText.Length; i++)
{
if (index < _sproteItemStartIndex.Count && _sproteItemStartIndex[index].StartIndex == i)
{
i += _sproteItemStartIndex[index].Length - 1;
index++;
continue;
}
for (int j = 0; j < 4; j++)
{
verTemp[j] = verts[i * 4 + j];
verTemp[j].position *= unitsPerPixel;
if (needOffset)
{
verTemp[j].position.x += offset.x;
verTemp[j].position.y += offset.y;
}
}
toFill.AddUIVertexQuad(verTemp);
}
}
void FillOutWire(VertexHelper vh)
{
if (m_OutWireSize > 0)
{
Quaternion nor = Quaternion.AngleAxis(90, Vector3.forward);
for (int i = 0; i < m_Sides; i++)
{
Vector3 dir = tempVerts[i + 2].position - tempVerts[i + 1].position;
dir = nor * (dir.normalized * m_OutWireSize * 0.5f);
UIVertex vert = new UIVertex();
vert.position = tempVerts[i + 1].position + dir;
vert.color = m_WireColor;
vert.uv0 = new Vector2(0, 1);
wireQuad[0] = vert;
vert = new UIVertex();
vert.position = tempVerts[i + 2].position + dir;
vert.color = m_WireColor;
vert.uv0 = Vector2.one;
wireQuad[1] = vert;
vert = new UIVertex();
vert.position = tempVerts[i + 2].position - dir;
vert.color = m_WireColor;
vert.uv0 = new Vector2(1, 0);
wireQuad[2] = vert;
vert = new UIVertex();
vert.position = tempVerts[i + 1].position - dir;
vert.color = m_WireColor;
vert.uv0 = Vector2.zero;
wireQuad[3] = vert;
vh.AddUIVertexQuad(wireQuad);
}
}
}
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)
{
vh.Clear();
Vector2 prevX = Vector2.zero;
Vector2 prevY = Vector2.zero;
Vector2 uv0 = new Vector2(0, 0);
Vector2 uv1 = new Vector2(0, 1);
Vector2 uv2 = new Vector2(1, 1);
Vector2 uv3 = new Vector2(1, 0);
Vector2 pos0;
Vector2 pos1;
Vector2 pos2;
Vector2 pos3;
float degrees = 360f / sides;
int vertices = sides + 1;
if (VerticesDistances.Length != vertices)
{
VerticesDistances = new float[vertices];
for (int i = 0; i < vertices - 1; i++) VerticesDistances[i] = 1;
}
// last vertex is also the first!
VerticesDistances[vertices - 1] = VerticesDistances[0];
for (int i = 0; i < vertices; i++)
{
float outer = -rectTransform.pivot.x * size * VerticesDistances[i];
float inner = -rectTransform.pivot.x * size * VerticesDistances[i] + thickness;
float rad = Mathf.Deg2Rad * (i * degrees + rotation);
float c = Mathf.Cos(rad);
float s = Mathf.Sin(rad);
uv0 = new Vector2(0, 1);
uv1 = new Vector2(1, 1);
uv2 = new Vector2(1, 0);
uv3 = new Vector2(0, 0);
pos0 = prevX;
pos1 = new Vector2(outer * c, outer * s);
if (fill)
{
pos2 = Vector2.zero;
pos3 = Vector2.zero;
}
else
{
pos2 = new Vector2(inner * c, inner * s);
pos3 = prevY;
}
prevX = pos1;
prevY = pos2;
vh.AddUIVertexQuad(SetVbo(new[] { pos0, pos1, pos2, pos3 }, new[] { uv0, uv1, uv2, uv3 }));
}
}
protected override void OnPopulateMesh(Mesh toFill)
{
// requires sets of quads
if (Points == null || Points.Length < 2)
Points = new[] { new Vector2(0, 0), new Vector2(1, 1) };
var capSize = 24;
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;
}
// build a new set of points taking into account the cap sizes.
// would be cool to support corners too, but that might be a bit tough :)
var pointList = new List<Vector2>();
pointList.Add(Points[0]);
var capPoint = Points[0] + (Points[1] - Points[0]).normalized * capSize;
pointList.Add(capPoint);
// should bail before the last point to add another cap point
for (int i = 1; i < Points.Length - 1; i++)
{
pointList.Add(Points[i]);
}
capPoint = Points[Points.Length - 1] - (Points[Points.Length - 1] - Points[Points.Length - 2]).normalized * capSize;
pointList.Add(capPoint);
pointList.Add(Points[Points.Length - 1]);
var TempPoints = pointList.ToArray();
if (UseMargins)
{
sizeX -= Margin.x;
sizeY -= Margin.y;
offsetX += Margin.x / 2f;
offsetY += Margin.y / 2f;
}
toFill.Clear();
var vbo = new VertexHelper(toFill);
Vector2 prevV1 = Vector2.zero;
Vector2 prevV2 = Vector2.zero;
for (int i = 1; i < TempPoints.Length; i++)
{
var prev = TempPoints[i - 1];
var cur = TempPoints[i];
prev = new Vector2(prev.x * sizeX + offsetX, prev.y * sizeY + offsetY);
cur = new Vector2(cur.x * sizeX + offsetX, cur.y * sizeY + offsetY);
float angle = Mathf.Atan2(cur.y - prev.y, cur.x - prev.x) * 180f / Mathf.PI;
var v1 = prev + new Vector2(0, -LineThickness / 2);
var v2 = prev + new Vector2(0, +LineThickness / 2);
var v3 = cur + new Vector2(0, +LineThickness / 2);
var v4 = cur + new Vector2(0, -LineThickness / 2);
v1 = RotatePointAroundPivot(v1, prev, new Vector3(0, 0, angle));
v2 = RotatePointAroundPivot(v2, prev, new Vector3(0, 0, angle));
v3 = RotatePointAroundPivot(v3, cur, new Vector3(0, 0, angle));
v4 = RotatePointAroundPivot(v4, cur, new Vector3(0, 0, angle));
Vector2 uvTopLeft = Vector2.zero;
Vector2 uvBottomLeft = new Vector2(0, 1);
Vector2 uvTopCenter = new Vector2(0.5f, 0);
Vector2 uvBottomCenter = new Vector2(0.5f, 1);
Vector2 uvTopRight = new Vector2(1, 0);
Vector2 uvBottomRight = new Vector2(1, 1);
Vector2[] uvs = new[] { uvTopCenter, uvBottomCenter, uvBottomCenter, uvTopCenter };
if (i > 1)
vbo.AddUIVertexQuad(SetVbo(new[] { prevV1, prevV2, v1, v2 }, uvs));
if (i == 1)
uvs = new[] { uvTopLeft, uvBottomLeft, uvBottomCenter, uvTopCenter };
else if (i == TempPoints.Length - 1)
uvs = new[] { uvTopCenter, uvBottomCenter, uvBottomRight, uvTopRight };
vbo.AddUIVertexQuad(SetVbo(new[] { v1, v2, v3, v4 }, uvs));
prevV1 = v3;
prevV2 = v4;
}
if (vbo.currentVertCount > 3)
{
vbo.FillMesh(toFill);
}
}
protected override void OnPopulateMesh(VertexHelper toFill)
{
if (font == null)
return;
// We don't care if we the font Texture changes while we are doing our Update.
// The end result of cachedTextGenerator will be valid for this instance.
// Otherwise we can get issues like Case 619238.
m_DisableFontTextureRebuiltCallback = true;
Vector2 extents = rectTransform.rect.size;
var settings = GetGenerationSettings(extents);
cachedTextGenerator.Populate(text, settings);
Rect inputRect = rectTransform.rect;
// get the text alignment anchor point for the text in local space
Vector2 textAnchorPivot = GetTextAnchorPivot(alignment);
Vector2 refPoint = Vector2.zero;
refPoint.x = (textAnchorPivot.x == 1 ? inputRect.xMax : inputRect.xMin);
refPoint.y = (textAnchorPivot.y == 0 ? inputRect.yMin : inputRect.yMax);
// Determine fraction of pixel to offset text mesh.
Vector2 roundingOffset = PixelAdjustPoint(refPoint) - refPoint;
// --- Changes ----
// Not really good place to put it, need to find somewhere else.
univTextGroup = new UnivTextGroup(m_Text);
alignment = univTextGroup.IsGroupRTL ? TextAnchor.MiddleRight : TextAnchor.MiddleLeft;
cachedTextGenerator.Populate(univTextGroup.CorrectedString(), settings);
// ---- End of changes ----
// Apply the offset to the vertices
IList<UIVertex> verts = cachedTextGenerator.verts;
float unitsPerPixel = 1/pixelsPerUnit;
//Last 4 verts are always a new line...
int vertCount = verts.Count - 4;
toFill.Clear();
if (roundingOffset != Vector2.zero)
{
for (int i = 0; i < vertCount; ++i)
{
int tempVertsIndex = i & 3;
m_TempVerts[tempVertsIndex] = verts[i];
m_TempVerts[tempVertsIndex].position *= unitsPerPixel;
m_TempVerts[tempVertsIndex].position.x += roundingOffset.x;
m_TempVerts[tempVertsIndex].position.y += roundingOffset.y;
if (tempVertsIndex == 3)
toFill.AddUIVertexQuad(m_TempVerts);
}
}
else
{
for (int i = 0; i < vertCount; ++i)
{
int tempVertsIndex = i & 3;
m_TempVerts[tempVertsIndex] = verts[i];
m_TempVerts[tempVertsIndex].position *= unitsPerPixel;
if (tempVertsIndex == 3)
toFill.AddUIVertexQuad(m_TempVerts);
}
}
m_DisableFontTextureRebuiltCallback = false;
}
protected override void OnPopulateMesh(VertexHelper vh) {
#if UNITY_EDITOR
if (!Application.isPlaying) {
if (!Initialize()) {
return;
}
}
#endif
// prepare vertices
vh.Clear();
if (!gameObject.activeInHierarchy) {
return;
}
// iterate through current particles
int count = _particleSystem.GetParticles(_particles);
for (int i = 0; i < count; ++i) {
ParticleSystem.Particle particle = _particles[i];
// get particle properties
Vector2 position = (_particleSystem.simulationSpace == ParticleSystemSimulationSpace.Local ? particle.position : _transform.InverseTransformPoint(particle.position));
float rotation = -particle.rotation * Mathf.Deg2Rad;
float rotation90 = rotation + Mathf.PI / 2;
Color32 color = particle.GetCurrentColor(_particleSystem);
float size = particle.GetCurrentSize(_particleSystem) * 0.5f;
// apply scale
if (_particleSystem.scalingMode == ParticleSystemScalingMode.Shape) {
position /= canvas.scaleFactor;
}
// apply texture sheet animation
Vector4 particleUV = _uv;
if (_textureSheetAnimation.enabled) {
float frameProgress = 1 - (particle.remainingLifetime / particle.startLifetime);
// float frameProgress = textureSheetAnimation.frameOverTime.curveMin.Evaluate(1 - (particle.lifetime / particle.startLifetime)); // TODO - once Unity allows MinMaxCurve reading
frameProgress = Mathf.Repeat(frameProgress * _textureSheetAnimation.cycleCount, 1);
int frame = 0;
switch (_textureSheetAnimation.animation) {
case ParticleSystemAnimationType.WholeSheet:
frame = Mathf.FloorToInt(frameProgress * _textureSheetAnimationFrames);
break;
case ParticleSystemAnimationType.SingleRow:
frame = Mathf.FloorToInt(frameProgress * _textureSheetAnimation.numTilesX);
int row = _textureSheetAnimation.rowIndex;
// if (textureSheetAnimation.useRandomRow) { // FIXME - is this handled internally by rowIndex?
// row = Random.Range(0, textureSheetAnimation.numTilesY, using: particle.randomSeed);
// }
frame += row * _textureSheetAnimation.numTilesX;
break;
}
frame %= _textureSheetAnimationFrames;
particleUV.x = (frame % _textureSheetAnimation.numTilesX) * _textureSheedAnimationFrameSize.x;
particleUV.y = Mathf.FloorToInt(frame / _textureSheetAnimation.numTilesX) * _textureSheedAnimationFrameSize.y;
particleUV.z = particleUV.x + _textureSheedAnimationFrameSize.x;
particleUV.w = particleUV.y + _textureSheedAnimationFrameSize.y;
}
_quad[0] = UIVertex.simpleVert;
_quad[0].color = color;
_quad[0].uv0 = new Vector2(particleUV.x, particleUV.y);
_quad[1] = UIVertex.simpleVert;
_quad[1].color = color;
_quad[1].uv0 = new Vector2(particleUV.x, particleUV.w);
_quad[2] = UIVertex.simpleVert;
_quad[2].color = color;
_quad[2].uv0 = new Vector2(particleUV.z, particleUV.w);
_quad[3] = UIVertex.simpleVert;
_quad[3].color = color;
_quad[3].uv0 = new Vector2(particleUV.z, particleUV.y);
if (rotation == 0) {
// no rotation
Vector2 corner1 = new Vector2(position.x - size, position.y - size);
Vector2 corner2 = new Vector2(position.x + size, position.y + size);
_quad[0].position = new Vector2(corner1.x, corner1.y);
_quad[1].position = new Vector2(corner1.x, corner2.y);
_quad[2].position = new Vector2(corner2.x, corner2.y);
_quad[3].position = new Vector2(corner2.x, corner1.y);
} else {
// apply rotation
Vector2 right = new Vector2(Mathf.Cos(rotation), Mathf.Sin(rotation)) * size;
Vector2 up = new Vector2(Mathf.Cos(rotation90), Mathf.Sin(rotation90)) * size;
_quad[0].position = position - right - up;
_quad[1].position = position - right + up;
_quad[2].position = position + right + up;
_quad[3].position = position + right - up;
}
vh.AddUIVertexQuad(_quad);
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
float outer = -rectTransform.pivot.x * rectTransform.rect.width;
float inner = -rectTransform.pivot.x * rectTransform.rect.width + this.thickness;
vh.Clear();
Vector2 prevX = Vector2.zero;
Vector2 prevY = Vector2.zero;
Vector2 uv0 = new Vector2(0, 0);
Vector2 uv1 = new Vector2(0, 1);
Vector2 uv2 = new Vector2(1, 1);
Vector2 uv3 = new Vector2(1, 0);
Vector2 pos0;
Vector2 pos1;
Vector2 pos2;
Vector2 pos3;
float f = (this.fillPercent / 100f);
float degrees = 360f / segments;
int fa = (int)((segments + 1) * f);
for (int i = 0; i < fa; i++)
{
float rad = Mathf.Deg2Rad * (i * degrees);
float c = Mathf.Cos(rad);
float s = Mathf.Sin(rad);
uv0 = new Vector2(0, 1);
uv1 = new Vector2(1, 1);
uv2 = new Vector2(1, 0);
uv3 = new Vector2(0, 0);
pos0 = prevX;
pos1 = new Vector2(outer * c, outer * s);
if (fill)
{
pos2 = Vector2.zero;
pos3 = Vector2.zero;
}
else
{
pos2 = new Vector2(inner * c, inner * s);
pos3 = prevY;
}
prevX = pos1;
prevY = pos2;
vh.AddUIVertexQuad(SetVbo(new[] { pos0, pos1, pos2, pos3 }, new[] { uv0, uv1, uv2, uv3 }));
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
float outer = -rectTransform.pivot.x * rectTransform.rect.width;
float inner = -rectTransform.pivot.x * rectTransform.rect.width + this.thickness;
vh.Clear();
Vector2 prevX = Vector2.zero;
Vector2 prevY = Vector2.zero;
Vector2 uv0 = new Vector2(0, 0);
Vector2 uv1 = new Vector2(0, 1);
Vector2 uv2 = new Vector2(1, 1);
Vector2 uv3 = new Vector2(1, 0);
Vector2 pos0;
Vector2 pos1;
Vector2 pos2;
Vector2 pos3;
if (FixedToSegments)
{
float f = (this.fillPercent / 100f);
float degrees = 360f / segments;
int fa = (int)((segments + 1) * f);
for (int i = 0; i < fa; i++)
{
float rad = Mathf.Deg2Rad * (i * degrees);
float c = Mathf.Cos(rad);
float s = Mathf.Sin(rad);
uv0 = new Vector2(0, 1);
uv1 = new Vector2(1, 1);
uv2 = new Vector2(1, 0);
uv3 = new Vector2(0, 0);
StepThroughPointsAndFill(outer, inner, ref prevX, ref prevY, out pos0, out pos1, out pos2, out pos3, c, s);
vh.AddUIVertexQuad(SetVbo(new[] { pos0, pos1, pos2, pos3 }, new[] { uv0, uv1, uv2, uv3 }));
}
}
else
{
float tw = rectTransform.rect.width;
float th = rectTransform.rect.height;
float angleByStep = (fillPercent / 100f * (Mathf.PI * 2f)) / segments;
float currentAngle = 0f;
for (int i = 0; i < segments + 1; i++)
{
float c = Mathf.Cos(currentAngle);
float s = Mathf.Sin(currentAngle);
StepThroughPointsAndFill(outer, inner, ref prevX, ref prevY, out pos0, out pos1, out pos2, out pos3, c, s);
uv0 = new Vector2(pos0.x / tw + 0.5f, pos0.y / th + 0.5f);
uv1 = new Vector2(pos1.x / tw + 0.5f, pos1.y / th + 0.5f);
uv2 = new Vector2(pos2.x / tw + 0.5f, pos2.y / th + 0.5f);
uv3 = new Vector2(pos3.x / tw + 0.5f, pos3.y / th + 0.5f);
vh.AddUIVertexQuad(SetVbo(new[] { pos0, pos1, pos2, pos3 }, new[] { uv0, uv1, uv2, uv3 }));
currentAngle += angleByStep;
}
}
}
protected override void OnPopulateMesh(VertexHelper vh)
{
vh.Clear();
if (Points.Length < 2)
return;
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;
var sizeVector = new Vector2(sizeX, sizeY);
var offsetVector = new Vector2(offsetX, offsetY);
for (var i = 0; i < Points.Length - 1; i++)
{
var current = new Vector2(Points[i].x * sizeVector.x, Points[i].y * sizeVector.y) + offsetVector;
var next = new Vector2(Points[i + 1].x * sizeVector.x, Points[i + 1].y * sizeVector.y) + offsetVector;
var line = next - current;
var normalized = line.normalized;
var up = normalized.Rotate(-90) * LineThickness / 2;
var vertices = new Vector2[4];
vertices[0] = current + up;
vertices[1] = next + up;
vertices[2] = next - up;
vertices[3] = current - up;
var uvs = new Vector2[4] { Vector2.zero, new Vector2(1, 0), Vector2.one, new Vector2(0, 1) };
vh.AddUIVertexQuad(CreateUIVertexQuad(vertices, uvs));
}
}
