/*
     * private void OnDrawGizmos() {
     *  if (debug) {
     *      if (debugSegList != null) {
     *          for (int i = 0; i < debugSegList.Count; i++) {
     *              Gizmos.color = Color.magenta;
     *              Gizmos.DrawLine(debugSegList[i].v1, debugSegList[i].v2);
     *          }
     *      }
     *  }
     * }
     */

    public override Mesh CreateMesh()
    {
        //print("Updating " + typeof(PathGroundCreator));
        debugSegList          = new List <LineSegment>();
        leaveHeightsUnchanged = new List <Vector3>();
        if (gridScale <= 0)
        {
            gridScale = 1f;
        }
        ClearOutput();
        if (pathCreator != null)
        {
            pathHeight = pathCreator.bezierPath.HeightOffset;
            if (!pathCreator.bezierPath.IsClosed && CheckConnection(0))
            {
                outerRing = new List <Vector3>(pathCreator.path.vertices);
                for (int i = 0; i < inputs.Length; i++)
                {
                    if (CheckConnection(i))
                    {
                        List <Vector3> edgeList = new List <Vector3>(inputs[i].Edge);
                        leaveHeightsUnchanged.AddRange(edgeList);
                        AddEdge(outerRing, edgeList);
                    }
                }
                ClosePath(outerRing, gridScale, pathHeight);
                bounds = GetBounds(outerRing);
            }
            else
            {
                outerRing = new List <Vector3>(pathCreator.path.vertices);
                bounds    = pathCreator.path.bounds;
            }
        }
        else if (CheckConnection(0))
        {
            outerRing = new List <Vector3>();
            for (int i = 0; i < inputs.Length; i++)
            {
                if (CheckConnection(i))
                {
                    if (outerRing.Count == 0)
                    {
                        outerRing.AddRange(new List <Vector3>(inputs[i].Edge));
                    }
                    else
                    {
                        AddEdge(outerRing, new List <Vector3>(inputs[i].Edge));
                    }
                }
            }
            if (outerRing.Count == 0)
            {
                print("Failed Ground Build");
                return(new Mesh());
            }

            leaveHeightsUnchanged.AddRange(outerRing);
            if (closed)
            {
                outerRing.Add(outerRing[0]);
            }
            else
            {
                ClosePath(outerRing, gridScale, 0);
            }

            bounds = GetBounds(outerRing);
        }
        else
        {
            return(new Mesh());
        }

        if (flipBorder)
        {
            outerRing.Reverse();
        }

        List <Vector3> validQuads = new List <Vector3>();
        List <Vector3> validTris  = new List <Vector3>();

        SetInnerRing(outerRing.ToArray(), validQuads, validTris);

        lineRing = SetLineSegmentRing(outerRing, innerRing);
        Utility.Polygon poly = SetOuterQuadsAndTris(lineRing);
        poly.Combine(AddInnerQuadsAndTris(validQuads, validTris));
        poly.verts = ModifyGroundHeights(poly.verts);

        Mesh mesh = new Mesh()
        {
            vertices  = poly.verts.ToArray(),
            triangles = poly.tris.ToArray(),
            uv        = poly.uvs.ToArray()
        };

        mesh.RecalculateNormals();

        FinishOutputs(ModifyGroundHeights(outerRing));

        return(mesh);
    }