PrimitiveUI.PrimitiveCanvas.PUIUtils Class Reference

Static Public Member Functions
static float	Cross2D (Vector2 lhs, Vector2 rhs)
static float	GetTriangleArea (Vector2 tri0, Vector2 tri1, Vector2 tri2)
static bool	PointInTriangle (Vector2 point, Vector2 tri0, Vector2 tri1, Vector2 tri2, float triAarea)
static ? Vector2	GetLineIntersection (Vector2 line1P1, Vector2 line1P2, Vector2 line2P1, Vector2 line2P2)
static Vector2[]	GetLinePoints (Vector2 point1, Vector2 point2, float strokeThickness, float aspectRatio)
static Vector2[]	GetPathPoints (Vector2[] points, bool closePath, float strokeThickness, float aspectRatio)

Detailed Description

Definition at line 133 of file PrimitiveCanvas.cs.

Member Function Documentation

Cross2D()

static float PrimitiveUI.PrimitiveCanvas.PUIUtils.Cross2D ( Vector2  lhs, Vector2  rhs  )

inlinestatic

Definition at line 135 of file PrimitiveCanvas.cs.

        {
            return lhs.x * rhs.y - lhs.y * rhs.x;
        }

GetLineIntersection()

static ? Vector2 PrimitiveUI.PrimitiveCanvas.PUIUtils.GetLineIntersection ( Vector2  line1P1, Vector2  line1P2, Vector2  line2P1, Vector2  line2P2  )

inlinestatic

Definition at line 156 of file PrimitiveCanvas.cs.

        {
            float num = (line2P2.y - line2P1.y) * (line1P2.x - line1P1.x) - (line2P2.x - line2P1.x) * (line1P2.y - line1P1.y);
            float num2 = (line2P2.x - line2P1.x) * (line1P1.y - line2P1.y) - (line2P2.y - line2P1.y) * (line1P1.x - line2P1.x);
            float f = (line1P2.x - line1P1.x) * (line1P1.y - line2P1.y) - (line1P2.y - line1P1.y) * (line1P1.x - line2P1.x);
            if (Mathf.Abs(num2) < Mathf.Epsilon && Mathf.Abs(f) < Mathf.Epsilon && Mathf.Abs(num) < Mathf.Epsilon)
            {
                return new Vector2((line1P1.x + line1P2.x) * 0.5f, (line1P1.y + line1P2.y) * 0.5f);
            }
            if (Mathf.Abs(num) < Mathf.Epsilon)
            {
                return null;
            }
            float num3 = num2 / num;
            return new Vector2(line1P1.x + num3 * (line1P2.x - line1P1.x), line1P1.y + num3 * (line1P2.y - line1P1.y));
        }

Referenced by PrimitiveUI.PrimitiveCanvas.PUIUtils.GetPathPoints().

GetLinePoints()

static Vector2[] PrimitiveUI.PrimitiveCanvas.PUIUtils.GetLinePoints ( Vector2  point1, Vector2  point2, float  strokeThickness, float  aspectRatio  )

inlinestatic

Definition at line 173 of file PrimitiveCanvas.cs.

        {
            Vector2 vector = new Vector2(strokeThickness, strokeThickness * aspectRatio);
            Vector2 normalized = (point2 - point1).normalized;
            Vector2 vector2 = new Vector2((0f - normalized.y) * vector.x, normalized.x * vector.y);
            return new Vector2[4]
            {
                point1 - vector2,
                point1 + vector2,
                point2 + vector2,
                point2 - vector2
            };
        }

References PrimitiveUI.PrimitiveCanvas.aspectRatio.

Referenced by PrimitiveUI.PrimitiveCanvas.DrawLine(), and PrimitiveUI.PrimitiveCanvas.OnRectTransformDimensionsChange().

GetPathPoints()

static Vector2[] PrimitiveUI.PrimitiveCanvas.PUIUtils.GetPathPoints ( Vector2[]  points, bool  closePath, float  strokeThickness, float  aspectRatio  )

inlinestatic

Definition at line 187 of file PrimitiveCanvas.cs.

        {
            Vector2 vector = new Vector2(strokeThickness, strokeThickness * aspectRatio);
            Vector2 normalized = (points[1] - points[0]).normalized;
            Vector2 vector2 = new Vector2((0f - normalized.y) * vector.x, normalized.x * vector.y);
            List<Vector2> list = new List<Vector2>();
            list.Add(points[0] - vector2);
            list.Add(points[0] + vector2);
            list.Add(points[1] + vector2);
            list.Add(points[1] - vector2);
            for (int i = 1; i < points.Length - 1; i++)
            {
                normalized = (points[i + 1] - points[i]).normalized;
                vector2 = new Vector2((0f - normalized.y) * vector.x, normalized.x * vector.y);
                list.Add(points[i] - vector2);
                list.Add(points[i] + vector2);
                list.Add(points[i + 1] + vector2);
                list.Add(points[i + 1] - vector2);
                Vector2? lineIntersection = GetLineIntersection(list[list.Count - 8], list[list.Count - 5], list[list.Count - 4], list[list.Count - 1]);
                Vector2? lineIntersection2 = GetLineIntersection(list[list.Count - 7], list[list.Count - 6], list[list.Count - 3], list[list.Count - 2]);
                if (lineIntersection.HasValue)
                {
                    Vector2 value = lineIntersection.Value;
                    int index = list.Count - 5;
                    Vector2 value2 = (list[list.Count - 4] = value);
                    list[index] = value2;
                }
                if (lineIntersection2.HasValue)
                {
                    Vector2 value = lineIntersection2.Value;
                    int index2 = list.Count - 6;
                    Vector2 value2 = (list[list.Count - 3] = value);
                    list[index2] = value2;
                }
            }
            if (closePath)
            {
                normalized = (points[^1] - points[0]).normalized;
                vector2 = new Vector2((0f - normalized.y) * vector.x, normalized.x * vector.y);
                list.Add(points[^1] - vector2);
                list.Add(points[^1] + vector2);
                list.Add(points[0] + vector2);
                list.Add(points[0] - vector2);
                Vector2? lineIntersection = GetLineIntersection(list[list.Count - 8], list[list.Count - 5], list[list.Count - 3], list[list.Count - 2]);
                Vector2? lineIntersection2 = GetLineIntersection(list[list.Count - 7], list[list.Count - 6], list[list.Count - 4], list[list.Count - 1]);
                if (lineIntersection.HasValue)
                {
                    Vector2 value = lineIntersection.Value;
                    int index3 = list.Count - 5;
                    Vector2 value2 = (list[list.Count - 3] = value);
                    list[index3] = value2;
                }
                if (lineIntersection2.HasValue)
                {
                    Vector2 value = lineIntersection2.Value;
                    int index4 = list.Count - 6;
                    Vector2 value2 = (list[list.Count - 4] = value);
                    list[index4] = value2;
                }
                lineIntersection = GetLineIntersection(list[3], list[0], list[list.Count - 3], list[list.Count - 2]);
                lineIntersection2 = GetLineIntersection(list[2], list[1], list[list.Count - 4], list[list.Count - 1]);
                if (lineIntersection.HasValue)
                {
                    Vector2 value = lineIntersection.Value;
                    Vector2 value2 = (list[list.Count - 2] = value);
                    list[0] = value2;
                }
                if (lineIntersection2.HasValue)
                {
                    Vector2 value = lineIntersection2.Value;
                    Vector2 value2 = (list[list.Count - 1] = value);
                    list[1] = value2;
                }
            }
            return list.ToArray();
        }

References PrimitiveUI.PrimitiveCanvas.aspectRatio, and PrimitiveUI.PrimitiveCanvas.PUIUtils.GetLineIntersection().

Referenced by PrimitiveUI.PrimitiveCanvas.DrawPath(), and PrimitiveUI.PrimitiveCanvas.OnRectTransformDimensionsChange().

GetTriangleArea()

static float PrimitiveUI.PrimitiveCanvas.PUIUtils.GetTriangleArea ( Vector2  tri0, Vector2  tri1, Vector2  tri2  )

inlinestatic

Definition at line 140 of file PrimitiveCanvas.cs.

        {
            return Mathf.Abs((0f - tri1.y) * tri2.x + tri0.y * (0f - tri1.x + tri2.x) + tri0.x * (tri1.y - tri2.y) + tri1.x * tri2.y);
        }

Referenced by PrimitiveUI.PrimitiveCanvas.DrawPolygon().

PointInTriangle()

static bool PrimitiveUI.PrimitiveCanvas.PUIUtils.PointInTriangle ( Vector2  point, Vector2  tri0, Vector2  tri1, Vector2  tri2, float  triAarea  )

inlinestatic

Definition at line 145 of file PrimitiveCanvas.cs.

        {
            float num = tri0.y * tri2.x - tri0.x * tri2.y + (tri2.y - tri0.y) * point.x + (tri0.x - tri2.x) * point.y;
            float num2 = tri0.x * tri1.y - tri0.y * tri1.x + (tri0.y - tri1.y) * point.x + (tri1.x - tri0.x) * point.y;
            if (num <= 0f || num2 <= 0f)
            {
                return false;
            }
            return num + num2 < triAarea;
        }

Referenced by PrimitiveUI.PrimitiveCanvas.DrawPolygon().

---

The documentation for this class was generated from the following file:

• Elin/Plugins.UI/PrimitiveUI/PrimitiveCanvas.cs