unity模型任意無限切割插件

原創 梁工123 2018-09-01 23:12

前面幾篇文章都是關於3d模型切割的原理，經過3天奮戰，完成了整個流程的製作，包括了滑動屏幕，切割模型的整個過程，因爲這個版本目前切割出來的切口處紋理統一使用uv座標我設定爲紅色，已經親測了無限切割（只要你的機器跟得上），本文難度其實挺大的，能理解的可以將他運用到其他平臺上，比如虛幻之類的，不能理解就只能直接在unity上使用了，希望使用的朋友能保留我的名字以及博客地址。如需下載完整插件，請到http://www.demodashi.com/demo/11343.html 。效果圖如下



想知道原理的可以查看這篇文章前面幾篇的內容，下面是完整代碼，可以直接在unity中運用的，

/*
 * @authors: liangjian
 * @desc:	
*/
using UnityEngine;
using System.Collections.Generic;
using UnityEngine.EventSystems;

public class TouchToPlane : MonoBehaviour {
    private bool m_IsClearSamePoint = false;
    private Vector3 m_TouchBeganPos;

    private Vector3 m_ClipPlaneNormal;
    private Vector3 m_ClipPlanePoint;

    // Use this for initialization
    void Start () {

    }

    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            m_TouchBeganPos = Input.mousePosition;
        }
        else if (Input.GetMouseButtonUp(0))
        {
            Vector3 touchBeganPoint_screen = new Vector3(m_TouchBeganPos.x, m_TouchBeganPos.y, Camera.main.nearClipPlane);
            Vector3 touchEndPoint_screen = new Vector3(Input.mousePosition.x, Input.mousePosition.y, Camera.main.nearClipPlane);
            Vector3 normalEndPoint_screen = new Vector3(m_TouchBeganPos.x, m_TouchBeganPos.y, Camera.main.nearClipPlane + 10);
            
            if(UpdateClipPlane(touchBeganPoint_screen, touchEndPoint_screen, normalEndPoint_screen))
            {
                ClipMesh();
            }
        }
    }

    bool UpdateClipPlane(Vector3 touchBeganPoint_sceen, Vector3 touchEndPoint_sceen, Vector3 normalEndPoint_screen)
    {
        if(Vector3.Distance(touchBeganPoint_sceen, touchEndPoint_sceen) == 0.0f)
        {
            return false;
        }
        //轉世界座標
        Vector3 touchBeganPoint_world = Camera.main.ScreenToWorldPoint(touchBeganPoint_sceen);
        Vector3 touchEndPoint_world = Camera.main.ScreenToWorldPoint(touchEndPoint_sceen);
        Vector3 noramlEndPoint_world = Camera.main.ScreenToWorldPoint(normalEndPoint_screen);

        //世界座標轉本地座標
        Vector3 touchBeginPoint_local = transform.worldToLocalMatrix.MultiplyPoint(touchBeganPoint_world);
        Vector3 touchEndPoint_local = transform.worldToLocalMatrix.MultiplyPoint(touchEndPoint_world);
        Vector3 normalEngPoint_local = transform.worldToLocalMatrix.MultiplyPoint(noramlEndPoint_world);

        m_ClipPlaneNormal = Vector3.Cross(normalEngPoint_local - touchBeginPoint_local, touchEndPoint_local - touchBeginPoint_local).normalized;
        m_ClipPlanePoint = touchEndPoint_local;

        return true;
    }

    void ClipMesh()
    {
        MeshFilter mf = this.gameObject.GetComponent<MeshFilter>();
        //頂點數組轉頂點容器
        List<Vector3> verticeList = new List<Vector3>();
        int verticeCount = mf.mesh.vertices.Length;
        for (int verticeIndex = 0; verticeIndex < verticeCount; ++verticeIndex)
        {
            verticeList.Add(mf.mesh.vertices[verticeIndex]);
        }
        //三角形數組轉三角形容器
        List<int> triangleList = new List<int>();
        int triangleCount = mf.mesh.triangles.Length;
        for (int triangleIndex = 0; triangleIndex < triangleCount; ++triangleIndex)
        {
            triangleList.Add(mf.mesh.triangles[triangleIndex]);
        }
        //uv座標數組轉uv座標容器
        List<Vector2> uvList = new List<Vector2>();
        int uvCount = mf.mesh.uv.Length;
        for (int uvIndex = 0; uvIndex < uvCount; ++uvIndex)
        {
            uvList.Add(mf.mesh.uv[uvIndex]);
        }
        //頂點顏色數組轉頂點顏色容器
        List<Vector3> normalList = new List<Vector3>();
        int normalCount = mf.mesh.normals.Length;
        for (int normalIndex = 0; normalIndex < normalCount; ++normalIndex)
        {
            normalList.Add(mf.mesh.normals[normalIndex]);
        }
        //Debug.Log("頂點數" + verticeList.Count);
        //Debug.Log("頂點索引數" + triangleList.Count);

        //檢查每個三角面，是否存在兩個頂點連接正好在直線上
        for (int triangleIndex = 0; triangleIndex < triangleList.Count;)
        {
            //Debug.Log("次數記錄");
            int trianglePointIndex0 = triangleList[triangleIndex];
            int trianglePointIndex1 = triangleList[triangleIndex + 1];
            int trianglePointIndex2 = triangleList[triangleIndex + 2];

            Vector3 trianglePointCoord0 = verticeList[trianglePointIndex0];
            Vector3 trianglePointCoord1 = verticeList[trianglePointIndex1];
            Vector3 trianglePointCoord2 = verticeList[trianglePointIndex2];

            //0-1，1-2相連線段被切割
            if(GetPointToClipPlaneDis(trianglePointCoord0)* GetPointToClipPlaneDis(trianglePointCoord1) < 0 && 
                GetPointToClipPlaneDis(trianglePointCoord1) * GetPointToClipPlaneDis(trianglePointCoord2) < 0)
            {
                //求得0-1與切平面的交點
                Vector3 newVertice01 = GetLinePlaneCrossPoint(trianglePointCoord0, trianglePointCoord1);
                int index01 = IsContainsVertice(verticeList, newVertice01);
                if (index01 == -1 || !m_IsClearSamePoint)
                {
                    verticeList.Add(newVertice01);
                    index01 = verticeList.Count - 1;
                    float k01 = 0;
                    if (!IsEqual(newVertice01.x, trianglePointCoord0.x) && !IsEqual(trianglePointCoord1.x, trianglePointCoord0.x))
                    {
                        k01 = (newVertice01.x - trianglePointCoord0.x) / (trianglePointCoord1.x - trianglePointCoord0.x);
                    }
                    else if (!IsEqual(newVertice01.y, trianglePointCoord0.y) && !IsEqual(trianglePointCoord1.y, trianglePointCoord0.y))
                    {
                        k01 = (newVertice01.y - trianglePointCoord0.y) / (trianglePointCoord1.y - trianglePointCoord0.y);
                    }
                    else
                    {
                        k01 = (newVertice01.z - trianglePointCoord0.z) / (trianglePointCoord1.z - trianglePointCoord0.z);
                    }
                    if (uvList.Count > 0)
                    {
                        Vector2 uv0 = uvList[trianglePointIndex0];
                        Vector2 uv1 = uvList[trianglePointIndex1];
                        
                        float newUV_x = (uv1.x - uv0.x) * k01 + uv0.x;
                        float newUV_y = (uv1.y - uv0.y) * k01 + uv0.y;
                        uvList.Add(new Vector2(newUV_x, newUV_y));
                        //Debug.Log("紋理座標" + uvList[uvList.Count - 1]);
                    }
                    //法向量
                    Vector3 normalX0 = normalList[trianglePointIndex0];
                    Vector3 normalX1 = normalList[trianglePointIndex1];
                    float newNoramlX01 = (normalX1.x - normalX0.x) * k01 + normalX0.x;
                    float newNoramlY01 = (normalX1.y - normalX0.y) * k01 + normalX0.y;
                    float newNoramlZ01 = (normalX1.z - normalX0.z) * k01 + normalX0.z;
                    normalList.Add(new Vector3(newNoramlX01, newNoramlY01, newNoramlZ01));
                }

                //求得1-2與切平面的交點
                Vector3 newVertice12 = GetLinePlaneCrossPoint(trianglePointCoord1, trianglePointCoord2);
                int index12 = IsContainsVertice(verticeList, newVertice12);
                if (index12 == -1 || !m_IsClearSamePoint)
                {
                    verticeList.Add(newVertice12);
                    index12 = verticeList.Count - 1;
                    float k12 = 0;
                    if (!IsEqual(newVertice12.x, trianglePointCoord1.x) && !IsEqual(trianglePointCoord2.x, trianglePointCoord1.x))
                    {
                        k12 = (newVertice12.x - trianglePointCoord1.x) / (trianglePointCoord2.x - trianglePointCoord1.x);
                    }
                    else if (!IsEqual(newVertice12.y, trianglePointCoord1.y) && !IsEqual(trianglePointCoord2.y, trianglePointCoord1.y))
                    {
                        k12 = (newVertice12.y - trianglePointCoord1.y) / (trianglePointCoord2.y - trianglePointCoord1.y);

                    }
                    else
                    {
                        k12 = (newVertice12.z - trianglePointCoord1.z) / (trianglePointCoord2.z - trianglePointCoord1.z);

                    }
                    if (uvList.Count > 0)
                    {
                        Vector2 uv1 = uvList[trianglePointIndex1];
                        Vector2 uv2 = uvList[trianglePointIndex2];

                        float newUV_x = (uv2.x - uv1.x) * k12 + uv1.x;
                        float newUV_y = (uv2.y - uv1.y) * k12 + uv1.y;
                        uvList.Add(new Vector2(newUV_x, newUV_y));
                        //Debug.Log("紋理座標" + uvList[uvList.Count - 1]);
                    }
                    //法向量
                    Vector3 normalX1 = normalList[trianglePointIndex1];
                    Vector3 normalX2 = normalList[trianglePointIndex2];
                    float newNoramlX12 = (normalX2.x - normalX1.x) * k12 + normalX1.x;
                    float newNoramlY12 = (normalX2.y - normalX1.y) * k12 + normalX1.y;
                    float newNoramlZ12 = (normalX2.z - normalX1.z) * k12 + normalX1.z;
                    normalList.Add(new Vector3(newNoramlX12, newNoramlY12, newNoramlZ12));
                }
                //插入頂點索引，以此構建新三角形
                triangleList.Insert(triangleIndex + 1, index01);
                triangleList.Insert(triangleIndex + 2, index12);

                triangleList.Insert(triangleIndex + 3, index12);
                triangleList.Insert(triangleIndex + 4, index01);

                triangleList.Insert(triangleIndex + 6, trianglePointIndex0);
                triangleList.Insert(triangleIndex + 7, index12);
                triangleIndex += 9;
            }
            //1-2，2-0相連線段被切割
            else if (GetPointToClipPlaneDis(trianglePointCoord1) * GetPointToClipPlaneDis(trianglePointCoord2) < 0 &&
                GetPointToClipPlaneDis(trianglePointCoord2) * GetPointToClipPlaneDis(trianglePointCoord0) < 0)
            {
                //求得1-2與切平面的交點
                Vector3 newVertice12 = GetLinePlaneCrossPoint(trianglePointCoord1, trianglePointCoord2);
                int index12 = IsContainsVertice(verticeList, newVertice12);
                if (index12 == -1 || !m_IsClearSamePoint)
                {
                    verticeList.Add(newVertice12);
                    index12 = verticeList.Count - 1;
                    float k12 = 0;
                    if(!IsEqual(newVertice12.x, trianglePointCoord1.x) && !IsEqual(trianglePointCoord2.x, trianglePointCoord1.x))
                    {
                        k12 = (newVertice12.x - trianglePointCoord1.x) / (trianglePointCoord2.x - trianglePointCoord1.x);
                    }
                    else if (!IsEqual(newVertice12.y, trianglePointCoord1.y) && !IsEqual(trianglePointCoord2.y, trianglePointCoord1.y))
                    {
                        k12 = (newVertice12.y - trianglePointCoord1.y) / (trianglePointCoord2.y - trianglePointCoord1.y);
                    }
                    else
                    {
                        k12 = (newVertice12.z - trianglePointCoord1.z) / (trianglePointCoord2.z - trianglePointCoord1.z);
                    }
                    if (uvList.Count > 0)
                    {
                        Vector2 uv1 = uvList[trianglePointIndex1];
                        Vector2 uv2 = uvList[trianglePointIndex2];

                        float newUV_x = (uv2.x - uv1.x) * k12 + uv1.x;
                        float newUV_y = (uv2.y - uv1.y) * k12 + uv1.y;
                        uvList.Add(new Vector2(newUV_x, newUV_y));
                        //Debug.Log("紋理座標" + uvList[uvList.Count - 1]);
                    }
                    //法向量
                    Vector3 normalX1 = normalList[trianglePointIndex1];
                    Vector3 normalX2 = normalList[trianglePointIndex2];
                    float newNoramlX12 = (normalX2.x - normalX1.x) * k12 + normalX1.x;
                    float newNoramlY12 = (normalX2.y - normalX1.y) * k12 + normalX1.y;
                    float newNoramlZ12 = (normalX2.z - normalX1.z) * k12 + normalX1.z;
                    normalList.Add(new Vector3(newNoramlX12, newNoramlY12, newNoramlZ12));
                }
                //求得0-2與切平面的交點
                Vector3 newVertice02 = GetLinePlaneCrossPoint(trianglePointCoord0, trianglePointCoord2);
                int index02 = IsContainsVertice(verticeList, newVertice02);
                if (index02 == -1 || !m_IsClearSamePoint)
                {
                    verticeList.Add(newVertice02);
                    index02 = verticeList.Count - 1;
                    float k02 = 0;
                    if (!IsEqual(newVertice02.x, trianglePointCoord0.x) && !IsEqual(trianglePointCoord2.x, trianglePointCoord0.x))
                    {
                        k02 = (newVertice02.x - trianglePointCoord0.x) / (trianglePointCoord2.x - trianglePointCoord0.x);
                        
                    }
                    else if (!IsEqual(newVertice02.y, trianglePointCoord0.y) && !IsEqual(trianglePointCoord2.y, trianglePointCoord0.y))
                    {
                        k02 = (newVertice02.y - trianglePointCoord0.y) / (trianglePointCoord2.y - trianglePointCoord0.y);
                    }
                    else
                    {
                        k02 = (newVertice02.z - trianglePointCoord0.z) / (trianglePointCoord2.z - trianglePointCoord0.z);
                    }
                    if (uvList.Count > 0)
                    {
                        Vector2 uv0 = uvList[trianglePointIndex0];
                        Vector2 uv2 = uvList[trianglePointIndex2];

                        float newUV_x = (uv2.x - uv0.x) * k02 + uv0.x;
                        float newUV_y = (uv2.y - uv0.y) * k02 + uv0.y;
                        uvList.Add(new Vector2(newUV_x, newUV_y));
                        //Debug.Log("紋理座標" + uvList[uvList.Count - 1]);
                    }
                    //法向量
                    Vector3 normalX0 = normalList[trianglePointIndex0];
                    Vector3 normalX2 = normalList[trianglePointIndex2];
                    float newNoramlX02 = (normalX2.x - normalX0.x) * k02 + normalX0.x;
                    float newNoramlY02 = (normalX2.y - normalX0.y) * k02 + normalX0.y;
                    float newNoramlZ02 = (normalX2.z - normalX0.z) * k02 + normalX0.z;
                    normalList.Add(new Vector3(newNoramlX02, newNoramlY02, newNoramlZ02));
                }
                //插入頂點索引，以此構建新三角形

                //{0}
                //{1}
                triangleList.Insert(triangleIndex + 2, index12);

                triangleList.Insert(triangleIndex + 3, index02);
                triangleList.Insert(triangleIndex + 4, index12);
                //{2}

                triangleList.Insert(triangleIndex + 6, index02);
                triangleList.Insert(triangleIndex + 7, trianglePointIndex0);
                triangleList.Insert(triangleIndex + 8, index12);
                triangleIndex += 9;
            }
            //0-1，2-0相連線段被切割
            else if (GetPointToClipPlaneDis(trianglePointCoord0) * GetPointToClipPlaneDis(trianglePointCoord1) < 0 &&
                GetPointToClipPlaneDis(trianglePointCoord2) * GetPointToClipPlaneDis(trianglePointCoord0) < 0)
            {
                //求得0-1與切平面的交點
                Vector3 newVertice01 = GetLinePlaneCrossPoint(trianglePointCoord0, trianglePointCoord1);
                int index01 = IsContainsVertice(verticeList, newVertice01);
                if (index01 == -1 || !m_IsClearSamePoint)
                {
                    verticeList.Add(newVertice01);
                    index01 = verticeList.Count - 1;
                    float k01 = 0;
                    if (!IsEqual(newVertice01.x, trianglePointCoord0.x) && !IsEqual(trianglePointCoord1.x, trianglePointCoord0.x))
                    {
                        k01 = (newVertice01.x - trianglePointCoord0.x) / (trianglePointCoord1.x - trianglePointCoord0.x);
                    }
                    else if(!IsEqual(newVertice01.y, trianglePointCoord0.y) && !IsEqual(trianglePointCoord1.y, trianglePointCoord0.y))
                    {
                        k01 = (newVertice01.y - trianglePointCoord0.y) / (trianglePointCoord1.y - trianglePointCoord0.y);
                    }
                    else
                    {
                        k01 = (newVertice01.z - trianglePointCoord0.z) / (trianglePointCoord1.z - trianglePointCoord0.z);
                    }
                    if (uvList.Count > 0)
                    {
                        Vector2 uv0 = uvList[trianglePointIndex0];
                        Vector2 uv1 = uvList[trianglePointIndex1];

                        float newUV_x = (uv1.x - uv0.x) * k01 + uv0.x;
                        float newUV_y = (uv1.y - uv0.y) * k01 + uv0.y;
                        uvList.Add(new Vector2(newUV_x, newUV_y));
                        Debug.Log("紋理座標" + uvList[uvList.Count - 1]);
                    }
                    //法向量
                    Vector3 normalX0 = normalList[trianglePointIndex0];
                    Vector3 normalX1 = normalList[trianglePointIndex1];
                    float newNoramlX01 = (normalX1.x - normalX0.x) * k01 + normalX0.x;
                    float newNoramlY01 = (normalX1.y - normalX0.y) * k01 + normalX0.y;
                    float newNoramlZ01 = (normalX1.z - normalX0.z) * k01 + normalX0.z;
                    normalList.Add(new Vector3(newNoramlX01, newNoramlY01, newNoramlZ01));
                }
                //求得0-2與切平面的交點
                Vector3 newVertice02 = GetLinePlaneCrossPoint(trianglePointCoord0, trianglePointCoord2);
                int index02 = IsContainsVertice(verticeList, newVertice02);
                if (index02 == -1 || !m_IsClearSamePoint)
                {
                    verticeList.Add(newVertice02);
                    index02 = verticeList.Count - 1;
                    float k02 = 0;
                    if (!IsEqual(newVertice02.x, trianglePointCoord0.x) && !IsEqual(trianglePointCoord2.x, trianglePointCoord0.x))
                    {
                        k02 = (newVertice02.x - trianglePointCoord0.x) / (trianglePointCoord2.x - trianglePointCoord0.x);
                    }
                    else if(!IsEqual(newVertice02.y, trianglePointCoord0.y) && !IsEqual(trianglePointCoord2.y, trianglePointCoord0.y))
                    {
                        k02 = (newVertice02.y - trianglePointCoord0.y) / (trianglePointCoord2.y - trianglePointCoord0.y);
                    }
                    else
                    {
                        k02 = (newVertice02.z - trianglePointCoord0.z) / (trianglePointCoord2.z - trianglePointCoord0.z);
                    }
                    if (uvList.Count > 0)
                    {
                        Vector2 uv0 = uvList[trianglePointIndex0];
                        Vector2 uv2 = uvList[trianglePointIndex2];

                        float newUV_x = (uv2.x - uv0.x) * k02 + uv0.x;
                        float newUV_y = (uv2.y - uv0.y) * k02 + uv0.y;
                        uvList.Add(new Vector2(newUV_x, newUV_y));
                        Debug.Log("紋理座標" + uvList[uvList.Count - 1]);
                    }
                    //法向量
                    Vector3 normalX0 = normalList[trianglePointIndex0];
                    Vector3 normalX2 = normalList[trianglePointIndex2];
                    float newNoramlX02 = (normalX2.x - normalX0.x) * k02 + normalX0.x;
                    float newNoramlY02 = (normalX2.y - normalX0.y) * k02 + normalX0.y;
                    float newNoramlZ02 = (normalX2.z - normalX0.z) * k02 + normalX0.z;
                    normalList.Add(new Vector3(newNoramlX02, newNoramlY02, newNoramlZ02));
                }
                //插入頂點索引，以此構建新三角形

                //{0}
                triangleList.Insert(triangleIndex + 1, index01);
                triangleList.Insert(triangleIndex + 2, index02);

                triangleList.Insert(triangleIndex + 3, index01);
                //{1}
                //{2}

                triangleList.Insert(triangleIndex + 6, trianglePointIndex2);
                triangleList.Insert(triangleIndex + 7, index02);
                triangleList.Insert(triangleIndex + 8, index01);
                triangleIndex += 9;
            }
            else
            {
                triangleIndex += 3;
            }
        }
        //Debug.Log("頂點數" + verticeList.Count);
        //Debug.Log("頂點索引數" + triangleList.Count);

        //篩選出切割面兩側的頂點索引
        List<int> triangles1 = new List<int>();
        List<int> triangles2 = new List<int>();
        for (int triangleIndex = 0; triangleIndex < triangleList.Count; triangleIndex += 3)
        {
            int trianglePoint0 = triangleList[triangleIndex];
            int trianglePoint1 = triangleList[triangleIndex + 1];
            int trianglePoint2 = triangleList[triangleIndex + 2];

            Vector3 point0 = verticeList[trianglePoint0];
            Vector3 point1 = verticeList[trianglePoint1];
            Vector3 point2 = verticeList[trianglePoint2];
            //切割面
            float dis0 = GetPointToClipPlaneDis(point0);
            float dis1 = GetPointToClipPlaneDis(point1);
            float dis2 = GetPointToClipPlaneDis(point2);

            if ((dis0 < 0 || IsEqual(dis0, 0)) && (dis1 < 0 || IsEqual(dis1, 0)) && (dis2 < 0 || IsEqual(dis2, 0)))
            {
                triangles1.Add(trianglePoint0);
                triangles1.Add(trianglePoint1);
                triangles1.Add(trianglePoint2);
            }
            else
            {
                triangles2.Add(trianglePoint0);
                triangles2.Add(trianglePoint1);
                triangles2.Add(trianglePoint2);
            }
        }

        //新生頂點數
        int newVerticeCount = verticeList.Count - verticeCount;
        //再次添加一遍新增頂點，用於縫合切口
        for (int newVerticeIndex = 0; newVerticeIndex < newVerticeCount; ++newVerticeIndex)
        {
            Vector3 newVertice = verticeList[verticeCount + newVerticeIndex];
            Vector3 qiekouVertice = new Vector3(newVertice.x, newVertice.y, newVertice.z);
            verticeList.Add(qiekouVertice);
            //uv
            if (uvList.Count > 0)
            {
                Vector2 newUv = uvList[verticeCount + newVerticeIndex];
                Vector2 qiekouUv = new Vector3(0.99f, 0.99f);
                uvList.Add(qiekouUv);
            }


            //法線
            Vector3 newNormal = normalList[verticeCount + newVerticeIndex];
            Vector3 qiekouNormal = new Vector3(newNormal.x, newNormal.y, newNormal.z);
            normalList.Add(qiekouNormal);
        }
        verticeCount = verticeCount + newVerticeCount;
        //重新排序新生成的頂點,按照角度
        List<SortAngle> SortAngleList = new List<SortAngle>();
        for (int verticeIndex = verticeCount + 1; verticeIndex < verticeList.Count; verticeIndex++)
        {
            //計算角度,以0-1爲參照
            Vector3 vec1to0 = verticeList[verticeCount + 1] - verticeList[verticeCount];
            Vector3 indexTo0 = verticeList[verticeIndex] - verticeList[verticeCount];

            float moIndexto0 = indexTo0.magnitude;
            float mo1to0 = vec1to0.magnitude;
            float dotRes = Vector3.Dot(indexTo0, vec1to0);
            if (moIndexto0 == 0.0f)
            {
                continue;
            }
            float angle = Mathf.Acos(dotRes / (mo1to0 * moIndexto0)); //Vector3.Angle(indexTo0.normalized, vec1to0.normalized);
            bool isExis = false;
            for (int i = 0; i < SortAngleList.Count; ++i)
            {
                //同樣角度，距離近的被剔除
                if (Mathf.Abs(SortAngleList[i].Angle * 180.0f / Mathf.PI - angle * 180.0f / Mathf.PI) < 0.1f)
                {
                    float dis1 = Vector3.Distance(verticeList[SortAngleList[i].Index], verticeList[verticeCount]);
                    float dis2 = Vector3.Distance(verticeList[verticeIndex], verticeList[verticeCount]);
                    if (dis2 >= dis1)
                    {
                        SortAngleList[i].Index = verticeIndex;
                    }
                    isExis = true;
                    break;
                }
            }
            if (!isExis)
            {
                //Debug.Log(angle);
                SortAngle sortAngle = new SortAngle();
                sortAngle.Index = verticeIndex;
                sortAngle.Angle = angle;
                SortAngleList.Add(sortAngle);
            }
        }
        SortAngleList.Sort();
        //縫合切口
        for (int verticeIndex = 0; verticeIndex < SortAngleList.Count - 1;)
        {
            triangles1.Add(SortAngleList[verticeIndex + 1].Index);
            triangles1.Add(SortAngleList[verticeIndex].Index);
            triangles1.Add(verticeCount);

            triangles2.Add(verticeCount);
            triangles2.Add(SortAngleList[verticeIndex].Index);
            triangles2.Add(SortAngleList[verticeIndex + 1].Index);


            verticeIndex++;
        }

        mf.mesh.vertices = verticeList.ToArray();
        mf.mesh.triangles = triangles1.ToArray();
        if (uvList.Count > 0)
        {
            mf.mesh.uv = uvList.ToArray();
        }
        mf.mesh.normals = normalList.ToArray();
        //分割模型
        GameObject newModel = new GameObject("New Model");
        MeshFilter meshFilter = newModel.AddComponent<MeshFilter>();
        meshFilter.mesh.vertices = mf.mesh.vertices;
        meshFilter.mesh.triangles = triangles2.ToArray();
        meshFilter.mesh.uv = mf.mesh.uv;
        meshFilter.mesh.normals = mf.mesh.normals;
        Renderer newRenderer = newModel.AddComponent<MeshRenderer>();
        newRenderer.material = this.gameObject.GetComponent<MeshRenderer>().material;
        newModel.transform.localPosition = transform.localPosition;
        newModel.AddComponent<TouchToPlane>();
    }

    float GetPointToClipPlaneDis(Vector3 point)
    {
        return Vector3.Dot((point - m_ClipPlanePoint), m_ClipPlaneNormal);
    }

    Vector3 GetLinePlaneCrossPoint(Vector3 lineBegin, Vector3 lineEnd)
    {
        //Debug.Log("起點：" + lineBegin + "," + "終點：" + lineEnd);
        float x = 0;
        float y = 0;
        float z = 0;
        float offsetZ = lineEnd.z - lineBegin.z;
        float offsetY = lineEnd.y - lineBegin.y;
        if (offsetZ != 0)
        {
            float k1 = (m_ClipPlaneNormal.x * (lineEnd.x - lineBegin.x) + m_ClipPlaneNormal.y * (lineEnd.y - lineBegin.y)) / offsetZ + m_ClipPlaneNormal.z;
            float k2 = (m_ClipPlaneNormal.x * lineBegin.z * (lineEnd.x - lineBegin.x) + m_ClipPlaneNormal.y * lineBegin.z * (lineEnd.y - lineBegin.y)) / offsetZ;
            float k3 = m_ClipPlaneNormal.x * lineBegin.x - m_ClipPlaneNormal.x * m_ClipPlanePoint.x + m_ClipPlaneNormal.y * lineBegin.y - m_ClipPlaneNormal.y * m_ClipPlanePoint.y - m_ClipPlaneNormal.z * m_ClipPlanePoint.z;
            z = (k2 - k3) / k1;
            x = (z - lineBegin.z) * (lineEnd.x - lineBegin.x) / offsetZ + lineBegin.x;
            y = (z - lineBegin.z) * (lineEnd.y - lineBegin.y) / offsetZ + lineBegin.y;
        }
        else if(offsetY != 0)
        {
            z = lineBegin.z;
            float k1 = m_ClipPlaneNormal.y + m_ClipPlaneNormal.x * (lineEnd.x - lineBegin.x) / (lineEnd.y - lineBegin.y);
            float k2 = m_ClipPlaneNormal.x * lineBegin.y * (lineEnd.x - lineBegin.x) / (lineEnd.y - lineBegin.y);
            float k3 = lineBegin.x* m_ClipPlaneNormal.x - m_ClipPlanePoint.x * m_ClipPlaneNormal.x - m_ClipPlaneNormal.y * m_ClipPlanePoint.y + m_ClipPlaneNormal.z * z - m_ClipPlaneNormal.z * m_ClipPlanePoint.z;
            y = (k2 - k3) / k1;
            x = (y - lineBegin.y) * (lineEnd.x - lineBegin.x) / (lineEnd.y - lineBegin.y) + lineBegin.x;
        }
        else
        {
            z = lineBegin.z;
            y = lineBegin.y;
            x = (m_ClipPlaneNormal.x * m_ClipPlanePoint.x - m_ClipPlaneNormal.y * (y - m_ClipPlanePoint.y) - m_ClipPlaneNormal.z * (z - m_ClipPlanePoint.z)) / m_ClipPlaneNormal.x;
        }



        // Debug.Log(x + "," + y + "," + z);
        return new Vector3(x, y, z);
    }

    int IsContainsVertice(List<Vector3> list, Vector3 vertice)
    {
        int count = list.Count;
        for(int i = 0; i < count; ++i)
        {
            Vector3 ii = list[i];
            if (IsEqual(ii.x, vertice.x) && IsEqual(ii.y, vertice.y) && IsEqual(ii.z, vertice.z))
            {
                return i;
            }
        }

        return -1;
    }

    bool IsEqual(float num1, float num2)
    {
        float absX = Mathf.Abs(num1 - num2);
        return absX < 0.00001f;
    }
}

/*
 * @authors: liangjian
 * @desc:	
*/
using UnityEngine;
using System.Collections;
using System;

public class SortAngle : IComparable<SortAngle> {
    public int Index;
    public float Angle;
    public int CompareTo(SortAngle item)
    {
        return item.Angle.CompareTo(Angle);
    }
}


















    





發表評論














所有評論



還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.







相關文章








OpenGL之旅（3）：繪製一個三角形






title: OpenGL(3)三角形
date: 2020-06-28 16:01
category: 圖形學
tags: opengl
https://hashwaney.github.io/
1.概述
VAO: 頂






 kk君

2020-07-08 08:39:50









OpenGL之旅（1）：初探






title: OpenGL(1)初探
date: 2020-06-28 7:30
category: 圖形學
tags: opengl
https://hashwaney.github.io/
1.OpenGL是什麼？
一般它






 kk君

2020-07-08 08:39:50









OpenGL之旅（2）：簡單的創建一個窗口






title: OpenGL(2)窗口
date: 2020-06-28 10:07
category: 圖形學
tags: opengl
鏈接:OpenGL(2)窗口
1. 視口
在開始渲染之前有一件重要的事情要做，就是告訴O






 kk君

2020-07-08 08:39:50









OpenGL(5)之紋理初探






title: OpenGL(5)之紋理初探
date: 2020-07-01 21:33
category: 圖形學
tags: opengl
鏈接：OpenGL(5)之紋理初探
1.概述
首先提出一個問題：什麼是紋理？
是由






 kk君

2020-07-08 08:39:50









Open之旅(4):着色器簡介






title: OpenGL(4)之着色器初探
date: 2020-06-30 18:10
category: 圖形學
tags: opengl
鏈接：OpenGL(4)之着色器初探
前言
着色器（Shader）是運行在GPU






 kk君

2020-07-08 08:39:50









Standard Two Sided Soft Blend






Shader "Custom/StandardTwoSidedSoftBlend"
{
    Properties{
        _Color("Color", Color) = (1,1,1,1)
        [NoScale






 Zerone羽

2020-07-08 02:30:58









blend關於透明度的弊端和其alphatest的取捨






首先需要說明的是，計算機在渲染一個模型的時候，並不存在什麼混合模式可以選擇，這個會對我們開發遊戲的過程帶來一個麻煩。比如：如果一個模型有兩層，最終渲染出來結果是前面一層擋住了了後面一層，各位看官可能會覺得擋住就擋住啊，反正看不見，可是當前






 梁工123

2020-07-08 01:57:31









Unity3d softInput decomplied java code






package com.unity3d.player;
import android.app.Dialog;
import android.content.Context;
import android.content.res.Reso






 延澈左

2020-07-08 09:56:18









Fedora安裝Unity Editor詳細步驟






本文固定鏈接，轉載請評論點贊，麼麼噠
一、起因：
最近一直在用Unity開發Linux版本的應用或者說遊戲。Linux是Fedora版本的。Unity官方很早就開始說要專門針對Linux做編輯器了。於是就萌生了要在Fedora上裝






 CattleDrinkRedWine

2020-07-08 09:14:00









Unity4.5動畫控制狀態切換監聽腳本






在Mecanim動畫由狀態機控制的情況下，監聽動畫狀態變化的代碼。可以根據需要，刪減其中的方法。
using UnityEngine;
using System.Collections;
using System.Collections.






 延澈左

2020-07-08 09:12:32









[Unity3D]灰度圖像Shader






昨天是清明節，也是深切哀悼新冠肺炎疫情犧牲烈士和逝世同胞的公祭日，致敬英雄，逝者安息！希望疫情早日過去！！！
看到許多網頁，以及一些朋友的微信頭像都變成了黑白色的，於是在想，複雜嗎？是如何實現的？
當輸出的RGB值相同的時候，就變






 延澈左

2020-07-08 09:12:32









[Unity3D]簡單的事件管理器






一個簡單的事件管理器
任意一個枚舉就可以定義事件類型。
using System.Collections.Generic;
using System;
public enum GameEvent
{
StartGame,






 延澈左

2020-07-08 09:12:32









[Unity3d]保存相機當前渲染內容或者RenderTexture到本地小工具






項目中，遇到需要將相機當前渲染的內容或者是RenderTexture保存到本地的需求，查看渲染結果是否正確。因此，寫了一個簡單的小工具，按F4就可以保存到Assets上一級目錄。
先直接貼代碼，有時間再詳細解釋
使用方式是直接






 延澈左

2020-07-08 09:12:32









Unity Shader CG 屬性類型和語義總結






UnityShader中屬性的類型：
_Color("Color",Color)=(1,1,1,1)
_Vector("Vector",Vector)=(1,2,3,4)
_Int("Int",Int)=34234
_Float("Flo






 Tian_kaifu

2020-07-08 03:52:20









Unity中的貝塞爾曲線思路及實現（轉）






轉https://blog.csdn.net/GhostOrange/article/details/53613372
 
說到貝塞爾曲線，大家肯定不會陌生，很多插件都有它的身影，但是想要一窺它的細節總覺得有點困難，因爲一到網上查詢都是什






 晴雨阳-_-!!!

2020-07-08 03:31:30