Unity代码编写自定义模型 修改器（可扩展）

代码很简单没有难度，自己看一下应该就能明白。
代码什么的还是可以进行二次补充像：地形编辑器、和LineRender嵌套使用啊，自己进行探索一下就可以复用了。
OK 老规矩，直接上代码：

自定义模型修改器

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 自定义模型 修改器（可扩展）
/// </summary>
public class CustomMesh_ZH : MonoBehaviour
{
    //网格组件
    private MeshFilter _MeshFilter;
    //渲染组件
    private MeshRenderer _MeshRender;
    //碰撞组件
    private MeshCollider _MeshCollider;

    //顶点数据 数组
    private List<Vector3> _Verts;
    //渲染序列
    private List<int> _Indices;


    [Header("节点坐标物体")]
    public List<Transform> _Vertss;

    [Header("材质球")]
    public Material _Material;
    private Vector2[] _UV;


    public static CustomMesh_ZH _CustomMesh_ZH;

    private void Awake()
    {
        //单列
        _CustomMesh_ZH = this;
        Initialize();

    }


    /// <summary>
    /// 数据生成
    /// </summary>
    public void Generate()
    {
        //数据清除
        CleraMeshData();

        //数据填充

        if (_isBoom)
        {
            StartCoroutine(AddMeshDataOpen());
        }
        else
        {
            StartCoroutine(AddMeshData());
        }


        //数据传递给 Mesh 生成网格数据
        //构造Mesh对象  
        Mesh _Mesh = new Mesh();
        //顶点数据加载读取
        _Mesh.vertices = _Verts.ToArray();
        //渲染序列加载读取
        _Mesh.triangles = _Indices.ToArray();

        //UV数据加载读取
        _Mesh.uv = _UV;

        //从顶点重新计算网格的边界体积。
        _Mesh.RecalculateNormals();
        //从三角形和顶点重新计算网格的法线
        _Mesh.RecalculateBounds();


        //网格数据加载
        _MeshFilter.mesh = _Mesh;
        //碰撞体添加
        _MeshCollider.sharedMesh = _Mesh;
        //材质球赋予
        _MeshRender.material = _Material;
    }

    /// <summary>
    /// 数据清除
    /// </summary>
    private void CleraMeshData()
    {
        _Verts.Clear();
        _Indices.Clear();
    }

    /// <summary>
    /// 数据填充  闭环
    /// </summary>
    private IEnumerator AddMeshData()
    {
        //节点数据添加
        for (int i = 0; i < _Vertss.Count; i++)
        {
            _Verts.Add(_Vertss[i].position);
        }


        //整体数组 三角构成判断
        switch (_Verts.Count % 3)
        {
            //完美耦合状态
            case 0:
                //循环渲染 三角数列
                for (int i = 1; i < _Verts.Count + 1; i++)
                {
                    三角面渲染
                    int _Index0 = 0;
                    int _Index1 = i;
                    int _Index2 = i + 1;

                    if (_Index2 >= _Verts.Count)
                    {
                        break;
                    }

                    //存储渲染序列
                    _Indices.Add(_Index0);
                    _Indices.Add(_Index1);
                    _Indices.Add(_Index2);
                    print(_Index0 + " " + _Index1 + " " + _Index2);
                }

                break;

            //余1状态
            case 1:

                //循环渲染 三角数列
                for (int i = 1; i < _Verts.Count; i++)
                {
                    //三角面渲染
                    int _Index0 = 0;
                    int _Index1 = i;
                    int _Index2 = i + 1;
                    //超出三角数列判定
                    if (_Index2 >= _Verts.Count)
                    {
                        break;
                    }

                    //余1状态 补充
                    if (i == _Verts.Count)
                    {
                        //三角面渲染
                        _Index0 = 0;
                        _Index1 = _Verts.Count - 1;
                        _Index2 = _Verts.Count;
                    }

                    //存储渲染序列
                    _Indices.Add(_Index0);
                    _Indices.Add(_Index1);
                    _Indices.Add(_Index2);
                    print(_Index0 + " " + _Index1 + " " + _Index2);
                }

                break;



            //余2状态
            case 2:

                //循环渲染 三角数列
                for (int i = 1; i < _Verts.Count; i++)
                {
                    //三角面渲染
                    int _Index0 = 0;
                    int _Index1 = i;
                    int _Index2 = i + 1;

                    //超出三角数列判定
                    if (_Index2 >= _Verts.Count)
                    {
                        break;
                    }


                    //余2状态 补充
                    if (i == _Verts.Count)
                    {
                        三角面渲染
                        _Index0 = 0;
                        _Index1 = _Verts.Count;
                        _Index2 = _Verts.Count - 1;
                    }

                    //存储渲染序列
                    _Indices.Add(_Index0);
                    _Indices.Add(_Index1);
                    _Indices.Add(_Index2);
                    print(_Index0 + " " + _Index1 + " " + _Index2);
                }

                break;

            default:
                break;
        }

        #region 循环渲染 三角数列  推演

        // 基础三角数列  推演
        //_Indices.Add(0); _Indices.Add(1); _Indices.Add(2);
        //_Indices.Add(2); _Indices.Add(3); _Indices.Add(4);
        //_Indices.Add(4); _Indices.Add(5); _Indices.Add(6);
        //_Indices.Add(6); _Indices.Add(7); _Indices.Add(8);
        //_Indices.Add(8); _Indices.Add(0); _Indices.Add(2);
        //_Indices.Add(2); _Indices.Add(4); _Indices.Add(6);
        //_Indices.Add(6); _Indices.Add(8); _Indices.Add(2);



        //for (int i = 0; i < _Verts.Count; i++)
        //{
        //    三角面渲染
        //    int _Index0 = i + _Number;
        //    int _Index1 = i + _Number + 1;
        //    int _Index2 = i + _Number + 2;
        //    _Number++;

        //    if (_Index2 > _Verts.Count)
        //    {
        //        _Number = 0;
        //        _Reuse.Add(0);
        //        _TwoReuse.Add(_Reuse[0]);

        //        for (int j = 0; j < _Reuse.Count; j++)
        //        {
        //            print(_Reuse[j]);
        //        }
        //        break;
        //    }
        #endregion


        yield return new WaitForSeconds(0.1f);

    }

    /// <summary>
    /// 数据填充  开环
    /// </summary>
    /// <returns></returns>
    private IEnumerator AddMeshDataOpen()
    {
        //节点数据添加
        for (int i = 0; i < _Vertss.Count; i++)
        {
            _Verts.Add(_Vertss[i].position);
        }

        int _Number = 0;
        //整体数组 三角构成判断
        switch (_Verts.Count % 3)
        {
            //完美耦合状态
            case 0:
                //循环渲染 三角数列
                for (int i = 0; i < _Verts.Count; i++)
                {
                    三角面渲染
                    int _Index0 = i + _Number;
                    int _Index1 = i + 1 + _Number;
                    int _Index2 = i + 2 + _Number;

                    if (_Index2 >= _Verts.Count)
                    {
                        break;
                    }

                    //存储渲染序列
                    _Indices.Add(_Index0);
                    _Indices.Add(_Index1);
                    _Indices.Add(_Index2);

                    _Number++;
                    print(_Index0 + " " + _Index1 + " " + _Index2);
                }

                break;

            //余1状态
            case 1:

                //循环渲染 三角数列
                for (int i = 0; i < _Verts.Count; i++)
                {
                    三角面渲染
                    int _Index0 = i + _Number;
                    int _Index1 = i + 1 + _Number;
                    int _Index2 = i + 2 + _Number;

                    if (_Index2 >= _Verts.Count - 1)
                    {
                        break;
                    }

                    //存储渲染序列
                    _Indices.Add(_Index0);
                    _Indices.Add(_Index1);
                    _Indices.Add(_Index2);

                    _Number++;
                    print(_Index0 + " " + _Index1 + " " + _Index2);
                }

                break;



            //余2状态
            case 2:

                //循环渲染 三角数列
                for (int i = 0; i < _Verts.Count; i++)
                {
                    三角面渲染
                    int _Index0 = i + _Number;
                    int _Index1 = i + 1 + _Number;
                    int _Index2 = i + 2 + _Number;

                    if (_Index2 >= _Verts.Count - 2)
                    {
                        break;
                    }

                    //存储渲染序列
                    _Indices.Add(_Index0);
                    _Indices.Add(_Index1);
                    _Indices.Add(_Index2);

                    _Number++;
                    print(_Index0 + " " + _Index1 + " " + _Index2);
                }

                break;

            default:
                break;
        }

        yield return new WaitForSeconds(0.1f);
    }

    /// <summary>
    /// 初始化
    /// </summary>
    private void Initialize()
    {
        _Verts = new List<Vector3>();
        _Indices = new List<int>();

        if (GetComponent<MeshFilter>() == null)
        {
            _MeshFilter = transform.gameObject.AddComponent<MeshFilter>();
        }
        else
        {
            _MeshFilter = GetComponent<MeshFilter>();
        }
        if (GetComponent<MeshRenderer>() == null)
        {
            _MeshRender = transform.gameObject.AddComponent<MeshRenderer>();
        }
        else
        {

            _MeshRender = GetComponent<MeshRenderer>();
        }
        if (GetComponent<MeshCollider>() == null)
        {
            _MeshCollider = transform.gameObject.AddComponent<MeshCollider>();
        }
        else
        {
            _MeshCollider = GetComponent<MeshCollider>();
        }
        //Generate();
    }

    bool _isBoom = false;
    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            _isBoom = !_isBoom;

        }
        Generate();
    }
}

组件搭载：

最终效果：
闭环

开环

暂时先这样吧，如果实在看不明白就留言，看到我会回复的。
这段时间遇到点事情，也没有更新内容什么的，也遇到了一些挺困扰的选择。
总之还是回来了，继续坚持吧。
路长远兮，与君共勉。