Esempio n. 1
0
 public CableCurve(CableCurve v)
 {
     points  = v.Points();
     m_start = v.start;
     m_end   = v.end;
     m_slack = v.slack;
     m_steps = v.steps;
     m_regen = v.regenPoints;
 }
Esempio n. 2
0
        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;
            }
        }