devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

unity模型任意无限切割插件_unity模型无限切割插件

作者：羊村懒王 | 2024-02-17 00:00:15

赞

踩

unity模型无限切割插件

前面几篇文章都是关于3d模型切割的原理，经过3天奋战，完成了整个流程的制作，包括了滑动屏幕，切割模型的整个过程，因为这个版本目前切割出来的切口处纹理统一使用uv坐标我设定为红色，已经亲测了无限切割（只要你的机器跟得上），本文难度其实挺大的，能理解的可以将他运用到其他平台上，比如虚幻之类的，不能理解就只能直接在unity上使用了，希望使用的朋友能保留我的名字以及博客地址。如需下载完整插件，请到http://www.demodashi.com/demo/11343.html 。效果图如下



想知道原理的可以查看这篇文章前面几篇的内容，下面是完整代码，可以直接在unity中运用的，

  1. /*
  2.  * @authors: liangjian
  3.  * @desc:	
  4. */
  5. using UnityEngine;
  6. using System.Collections.Generic;
  7. using UnityEngine.EventSystems;
  8.  
  9. public class TouchToPlane : MonoBehaviour {
  10.     private bool m_IsClearSamePoint = false;
  11.     private Vector3 m_TouchBeganPos;
  12.  
  13.     private Vector3 m_ClipPlaneNormal;
  14.     private Vector3 m_ClipPlanePoint;
  15.  
  16.     // Use this for initialization
  17.     void Start () {
  18.  
  19.     }
  20.  
  21.     void Update()
  22.     {
  23.         if (Input.GetMouseButtonDown(0))
  24.         {
  25.             m_TouchBeganPos = Input.mousePosition;
  26.         }
  27.         else if (Input.GetMouseButtonUp(0))
  28.         {
  29.             Vector3 touchBeganPoint_screen = new Vector3(m_TouchBeganPos.x, m_TouchBeganPos.y, Camera.main.nearClipPlane);
  30.             Vector3 touchEndPoint_screen = new Vector3(Input.mousePosition.x, Input.mousePosition.y, Camera.main.nearClipPlane);
  31.             Vector3 normalEndPoint_screen = new Vector3(m_TouchBeganPos.x, m_TouchBeganPos.y, Camera.main.nearClipPlane + 10);
  32.             
  33.             if(UpdateClipPlane(touchBeganPoint_screen, touchEndPoint_screen, normalEndPoint_screen))
  34.             {
  35.                 ClipMesh();
  36.             }
  37.         }
  38.     }
  39.  
  40.     bool UpdateClipPlane(Vector3 touchBeganPoint_sceen, Vector3 touchEndPoint_sceen, Vector3 normalEndPoint_screen)
  41.     {
  42.         if(Vector3.Distance(touchBeganPoint_sceen, touchEndPoint_sceen) == 0.0f)
  43.         {
  44.             return false;
  45.         }
  46.         //转世界坐标
  47.         Vector3 touchBeganPoint_world = Camera.main.ScreenToWorldPoint(touchBeganPoint_sceen);
  48.         Vector3 touchEndPoint_world = Camera.main.ScreenToWorldPoint(touchEndPoint_sceen);
  49.         Vector3 noramlEndPoint_world = Camera.main.ScreenToWorldPoint(normalEndPoint_screen);
  50.  
  51.         //世界坐标转本地坐标
  52.         Vector3 touchBeginPoint_local = transform.worldToLocalMatrix.MultiplyPoint(touchBeganPoint_world);
  53.         Vector3 touchEndPoint_local = transform.worldToLocalMatrix.MultiplyPoint(touchEndPoint_world);
  54.         Vector3 normalEngPoint_local = transform.worldToLocalMatrix.MultiplyPoint(noramlEndPoint_world);
  55.  
  56.         m_ClipPlaneNormal = Vector3.Cross(normalEngPoint_local - touchBeginPoint_local, touchEndPoint_local - touchBeginPoint_local).normalized;
  57.         m_ClipPlanePoint = touchEndPoint_local;
  58.  
  59.         return true;
  60.     }
  61.  
  62.     void ClipMesh()
  63.     {
  64.         MeshFilter mf = this.gameObject.GetComponent<MeshFilter>();
  65.         //顶点数组转顶点容器
  66.         List<Vector3> verticeList = new List<Vector3>();
  67.         int verticeCount = mf.mesh.vertices.Length;
  68.         for (int verticeIndex = 0; verticeIndex < verticeCount; ++verticeIndex)
  69.         {
  70.             verticeList.Add(mf.mesh.vertices[verticeIndex]);
  71.         }
  72.         //三角形数组转三角形容器
  73.         List<int> triangleList = new List<int>();
  74.         int triangleCount = mf.mesh.triangles.Length;
  75.         for (int triangleIndex = 0; triangleIndex < triangleCount; ++triangleIndex)
  76.         {
  77.             triangleList.Add(mf.mesh.triangles[triangleIndex]);
  78.         }
  79.         //uv坐标数组转uv坐标容器
  80.         List<Vector2> uvList = new List<Vector2>();
  81.         int uvCount = mf.mesh.uv.Length;
  82.         for (int uvIndex = 0; uvIndex < uvCount; ++uvIndex)
  83.         {
  84.             uvList.Add(mf.mesh.uv[uvIndex]);
  85.         }
  86.         //顶点颜色数组转顶点颜色容器
  87.         List<Vector3> normalList = new List<Vector3>();
  88.         int normalCount = mf.mesh.normals.Length;
  89.         for (int normalIndex = 0; normalIndex < normalCount; ++normalIndex)
  90.         {
  91.             normalList.Add(mf.mesh.normals[normalIndex]);
  92.         }
  93.         //Debug.Log("顶点数" + verticeList.Count);
  94.         //Debug.Log("顶点索引数" + triangleList.Count);
  95.  
  96.         //检查每个三角面，是否存在两个顶点连接正好在直线上
  97.         for (int triangleIndex = 0; triangleIndex < triangleList.Count;)
  98.         {
  99.             //Debug.Log("次数记录");
  100.             int trianglePointIndex0 = triangleList[triangleIndex];
  101.             int trianglePointIndex1 = triangleList[triangleIndex + 1];
  102.             int trianglePointIndex2 = triangleList[triangleIndex + 2];
  103.  
  104.             Vector3 trianglePointCoord0 = verticeList[trianglePointIndex0];
  105.             Vector3 trianglePointCoord1 = verticeList[trianglePointIndex1];
  106.             Vector3 trianglePointCoord2 = verticeList[trianglePointIndex2];
  107.  
  108.             //0-1，1-2相连线段被切割
  109.             if(GetPointToClipPlaneDis(trianglePointCoord0)* GetPointToClipPlaneDis(trianglePointCoord1) < 0 && 
  110.                 GetPointToClipPlaneDis(trianglePointCoord1) * GetPointToClipPlaneDis(trianglePointCoord2) < 0)
  111.             {
  112.                 //求得0-1与切平面的交点
  113.                 Vector3 newVertice01 = GetLinePlaneCrossPoint(trianglePointCoord0, trianglePointCoord1);
  114.                 int index01 = IsContainsVertice(verticeList, newVertice01);
  115.                 if (index01 == -1 || !m_IsClearSamePoint)
  116.                 {
  117.                     verticeList.Add(newVertice01);
  118.                     index01 = verticeList.Count - 1;
  119.                     float k01 = 0;
  120.                     if (!IsEqual(newVertice01.x, trianglePointCoord0.x) && !IsEqual(trianglePointCoord1.x, trianglePointCoord0.x))
  121.                     {
  122.                         k01 = (newVertice01.x - trianglePointCoord0.x) / (trianglePointCoord1.x - trianglePointCoord0.x);
  123.                     }
  124.                     else if (!IsEqual(newVertice01.y, trianglePointCoord0.y) && !IsEqual(trianglePointCoord1.y, trianglePointCoord0.y))
  125.                     {
  126.                         k01 = (newVertice01.y - trianglePointCoord0.y) / (trianglePointCoord1.y - trianglePointCoord0.y);
  127.                     }
  128.                     else
  129.                     {
  130.                         k01 = (newVertice01.z - trianglePointCoord0.z) / (trianglePointCoord1.z - trianglePointCoord0.z);
  131.                     }
  132.                     if (uvList.Count > 0)
  133.                     {
  134.                         Vector2 uv0 = uvList[trianglePointIndex0];
  135.                         Vector2 uv1 = uvList[trianglePointIndex1];
  136.                         
  137.                         float newUV_x = (uv1.x - uv0.x) * k01 + uv0.x;
  138.                         float newUV_y = (uv1.y - uv0.y) * k01 + uv0.y;
  139.                         uvList.Add(new Vector2(newUV_x, newUV_y));
  140.                         //Debug.Log("纹理坐标" + uvList[uvList.Count - 1]);
  141.                     }
  142.                     //法向量
  143.                     Vector3 normalX0 = normalList[trianglePointIndex0];
  144.                     Vector3 normalX1 = normalList[trianglePointIndex1];
  145.                     float newNoramlX01 = (normalX1.x - normalX0.x) * k01 + normalX0.x;
  146.                     float newNoramlY01 = (normalX1.y - normalX0.y) * k01 + normalX0.y;
  147.                     float newNoramlZ01 = (normalX1.z - normalX0.z) * k01 + normalX0.z;
  148.                     normalList.Add(new Vector3(newNoramlX01, newNoramlY01, newNoramlZ01));
  149.                 }
  150.  
  151.                 //求得1-2与切平面的交点
  152.                 Vector3 newVertice12 = GetLinePlaneCrossPoint(trianglePointCoord1, trianglePointCoord2);
  153.                 int index12 = IsContainsVertice(verticeList, newVertice12);
  154.                 if (index12 == -1 || !m_IsClearSamePoint)
  155.                 {
  156.                     verticeList.Add(newVertice12);
  157.                     index12 = verticeList.Count - 1;
  158.                     float k12 = 0;
  159.                     if (!IsEqual(newVertice12.x, trianglePointCoord1.x) && !IsEqual(trianglePointCoord2.x, trianglePointCoord1.x))
  160.                     {
  161.                         k12 = (newVertice12.x - trianglePointCoord1.x) / (trianglePointCoord2.x - trianglePointCoord1.x);
  162.                     }
  163.                     else if (!IsEqual(newVertice12.y, trianglePointCoord1.y) && !IsEqual(trianglePointCoord2.y, trianglePointCoord1.y))
  164.                     {
  165.                         k12 = (newVertice12.y - trianglePointCoord1.y) / (trianglePointCoord2.y - trianglePointCoord1.y);
  166.  
  167.                     }
  168.                     else
  169.                     {
  170.                         k12 = (newVertice12.z - trianglePointCoord1.z) / (trianglePointCoord2.z - trianglePointCoord1.z);
  171.  
  172.                     }
  173.                     if (uvList.Count > 0)
  174.                     {
  175.                         Vector2 uv1 = uvList[trianglePointIndex1];
  176.                         Vector2 uv2 = uvList[trianglePointIndex2];
  177.  
  178.                         float newUV_x = (uv2.x - uv1.x) * k12 + uv1.x;
  179.                         float newUV_y = (uv2.y - uv1.y) * k12 + uv1.y;
  180.                         uvList.Add(new Vector2(newUV_x, newUV_y));
  181.                         //Debug.Log("纹理坐标" + uvList[uvList.Count - 1]);
  182.                     }
  183.                     //法向量
  184.                     Vector3 normalX1 = normalList[trianglePointIndex1];
  185.                     Vector3 normalX2 = normalList[trianglePointIndex2];
  186.                     float newNoramlX12 = (normalX2.x - normalX1.x) * k12 + normalX1.x;
  187.                     float newNoramlY12 = (normalX2.y - normalX1.y) * k12 + normalX1.y;
  188.                     float newNoramlZ12 = (normalX2.z - normalX1.z) * k12 + normalX1.z;
  189.                     normalList.Add(new Vector3(newNoramlX12, newNoramlY12, newNoramlZ12));
  190.                 }
  191.                 //插入顶点索引，以此构建新三角形
  192.                 triangleList.Insert(triangleIndex + 1, index01);
  193.                 triangleList.Insert(triangleIndex + 2, index12);
  194.  
  195.                 triangleList.Insert(triangleIndex + 3, index12);
  196.                 triangleList.Insert(triangleIndex + 4, index01);
  197.  
  198.                 triangleList.Insert(triangleIndex + 6, trianglePointIndex0);
  199.                 triangleList.Insert(triangleIndex + 7, index12);
  200.                 triangleIndex += 9;
  201.             }
  202.             //1-2，2-0相连线段被切割
  203.             else if (GetPointToClipPlaneDis(trianglePointCoord1) * GetPointToClipPlaneDis(trianglePointCoord2) < 0 &&
  204.                 GetPointToClipPlaneDis(trianglePointCoord2) * GetPointToClipPlaneDis(trianglePointCoord0) < 0)
  205.             {
  206.                 //求得1-2与切平面的交点
  207.                 Vector3 newVertice12 = GetLinePlaneCrossPoint(trianglePointCoord1, trianglePointCoord2);
  208.                 int index12 = IsContainsVertice(verticeList, newVertice12);
  209.                 if (index12 == -1 || !m_IsClearSamePoint)
  210.                 {
  211.                     verticeList.Add(newVertice12);
  212.                     index12 = verticeList.Count - 1;
  213.                     float k12 = 0;
  214.                     if(!IsEqual(newVertice12.x, trianglePointCoord1.x) && !IsEqual(trianglePointCoord2.x, trianglePointCoord1.x))
  215.                     {
  216.                         k12 = (newVertice12.x - trianglePointCoord1.x) / (trianglePointCoord2.x - trianglePointCoord1.x);
  217.                     }
  218.                     else if (!IsEqual(newVertice12.y, trianglePointCoord1.y) && !IsEqual(trianglePointCoord2.y, trianglePointCoord1.y))
  219.                     {
  220.                         k12 = (newVertice12.y - trianglePointCoord1.y) / (trianglePointCoord2.y - trianglePointCoord1.y);
  221.                     }
  222.                     else
  223.                     {
  224.                         k12 = (newVertice12.z - trianglePointCoord1.z) / (trianglePointCoord2.z - trianglePointCoord1.z);
  225.                     }
  226.                     if (uvList.Count > 0)
  227.                     {
  228.                         Vector2 uv1 = uvList[trianglePointIndex1];
  229.                         Vector2 uv2 = uvList[trianglePointIndex2];
  230.  
  231.                         float newUV_x = (uv2.x - uv1.x) * k12 + uv1.x;
  232.                         float newUV_y = (uv2.y - uv1.y) * k12 + uv1.y;
  233.                         uvList.Add(new Vector2(newUV_x, newUV_y));
  234.                         //Debug.Log("纹理坐标" + uvList[uvList.Count - 1]);
  235.                     }
  236.                     //法向量
  237.                     Vector3 normalX1 = normalList[trianglePointIndex1];
  238.                     Vector3 normalX2 = normalList[trianglePointIndex2];
  239.                     float newNoramlX12 = (normalX2.x - normalX1.x) * k12 + normalX1.x;
  240.                     float newNoramlY12 = (normalX2.y - normalX1.y) * k12 + normalX1.y;
  241.                     float newNoramlZ12 = (normalX2.z - normalX1.z) * k12 + normalX1.z;
  242.                     normalList.Add(new Vector3(newNoramlX12, newNoramlY12, newNoramlZ12));
  243.                 }
  244.                 //求得0-2与切平面的交点
  245.                 Vector3 newVertice02 = GetLinePlaneCrossPoint(trianglePointCoord0, trianglePointCoord2);
  246.                 int index02 = IsContainsVertice(verticeList, newVertice02);
  247.                 if (index02 == -1 || !m_IsClearSamePoint)
  248.                 {
  249.                     verticeList.Add(newVertice02);
  250.                     index02 = verticeList.Count - 1;
  251.                     float k02 = 0;
  252.                     if (!IsEqual(newVertice02.x, trianglePointCoord0.x) && !IsEqual(trianglePointCoord2.x, trianglePointCoord0.x))
  253.                     {
  254.                         k02 = (newVertice02.x - trianglePointCoord0.x) / (trianglePointCoord2.x - trianglePointCoord0.x);
  255.                         
  256.                     }
  257.                     else if (!IsEqual(newVertice02.y, trianglePointCoord0.y) && !IsEqual(trianglePointCoord2.y, trianglePointCoord0.y))
  258.                     {
  259.                         k02 = (newVertice02.y - trianglePointCoord0.y) / (trianglePointCoord2.y - trianglePointCoord0.y);
  260.                     }
  261.                     else
  262.                     {
  263.                         k02 = (newVertice02.z - trianglePointCoord0.z) / (trianglePointCoord2.z - trianglePointCoord0.z);
  264.                     }
  265.                     if (uvList.Count > 0)
  266.                     {
  267.                         Vector2 uv0 = uvList[trianglePointIndex0];
  268.                         Vector2 uv2 = uvList[trianglePointIndex2];
  269.  
  270.                         float newUV_x = (uv2.x - uv0.x) * k02 + uv0.x;
  271.                         float newUV_y = (uv2.y - uv0.y) * k02 + uv0.y;
  272.                         uvList.Add(new Vector2(newUV_x, newUV_y));
  273.                         //Debug.Log("纹理坐标" + uvList[uvList.Count - 1]);
  274.                     }
  275.                     //法向量
  276.                     Vector3 normalX0 = normalList[trianglePointIndex0];
  277.                     Vector3 normalX2 = normalList[trianglePointIndex2];
  278.                     float newNoramlX02 = (normalX2.x - normalX0.x) * k02 + normalX0.x;
  279.                     float newNoramlY02 = (normalX2.y - normalX0.y) * k02 + normalX0.y;
  280.                     float newNoramlZ02 = (normalX2.z - normalX0.z) * k02 + normalX0.z;
  281.                     normalList.Add(new Vector3(newNoramlX02, newNoramlY02, newNoramlZ02));
  282.                 }
  283.                 //插入顶点索引，以此构建新三角形
  284.  
  285.                 //{0}
  286.                 //{1}
  287.                 triangleList.Insert(triangleIndex + 2, index12);
  288.  
  289.                 triangleList.Insert(triangleIndex + 3, index02);
  290.                 triangleList.Insert(triangleIndex + 4, index12);
  291.                 //{2}
  292.  
  293.                 triangleList.Insert(triangleIndex + 6, index02);
  294.                 triangleList.Insert(triangleIndex + 7, trianglePointIndex0);
  295.                 triangleList.Insert(triangleIndex + 8, index12);
  296.                 triangleIndex += 9;
  297.             }
  298.             //0-1，2-0相连线段被切割
  299.             else if (GetPointToClipPlaneDis(trianglePointCoord0) * GetPointToClipPlaneDis(trianglePointCoord1) < 0 &&
  300.                 GetPointToClipPlaneDis(trianglePointCoord2) * GetPointToClipPlaneDis(trianglePointCoord0) < 0)
  301.             {
  302.                 //求得0-1与切平面的交点
  303.                 Vector3 newVertice01 = GetLinePlaneCrossPoint(trianglePointCoord0, trianglePointCoord1);
  304.                 int index01 = IsContainsVertice(verticeList, newVertice01);
  305.                 if (index01 == -1 || !m_IsClearSamePoint)
  306.                 {
  307.                     verticeList.Add(newVertice01);
  308.                     index01 = verticeList.Count - 1;
  309.                     float k01 = 0;
  310.                     if (!IsEqual(newVertice01.x, trianglePointCoord0.x) && !IsEqual(trianglePointCoord1.x, trianglePointCoord0.x))
  311.                     {
  312.                         k01 = (newVertice01.x - trianglePointCoord0.x) / (trianglePointCoord1.x - trianglePointCoord0.x);
  313.                     }
  314.                     else if(!IsEqual(newVertice01.y, trianglePointCoord0.y) && !IsEqual(trianglePointCoord1.y, trianglePointCoord0.y))
  315.                     {
  316.                         k01 = (newVertice01.y - trianglePointCoord0.y) / (trianglePointCoord1.y - trianglePointCoord0.y);
  317.                     }
  318.                     else
  319.                     {
  320.                         k01 = (newVertice01.z - trianglePointCoord0.z) / (trianglePointCoord1.z - trianglePointCoord0.z);
  321.                     }
  322.                     if (uvList.Count > 0)
  323.                     {
  324.                         Vector2 uv0 = uvList[trianglePointIndex0];
  325.                         Vector2 uv1 = uvList[trianglePointIndex1];
  326.  
  327.                         float newUV_x = (uv1.x - uv0.x) * k01 + uv0.x;
  328.                         float newUV_y = (uv1.y - uv0.y) * k01 + uv0.y;
  329.                         uvList.Add(new Vector2(newUV_x, newUV_y));
  330.                         Debug.Log("纹理坐标" + uvList[uvList.Count - 1]);
  331.                     }
  332.                     //法向量
  333.                     Vector3 normalX0 = normalList[trianglePointIndex0];
  334.                     Vector3 normalX1 = normalList[trianglePointIndex1];
  335.                     float newNoramlX01 = (normalX1.x - normalX0.x) * k01 + normalX0.x;
  336.                     float newNoramlY01 = (normalX1.y - normalX0.y) * k01 + normalX0.y;
  337.                     float newNoramlZ01 = (normalX1.z - normalX0.z) * k01 + normalX0.z;
  338.                     normalList.Add(new Vector3(newNoramlX01, newNoramlY01, newNoramlZ01));
  339.                 }
  340.                 //求得0-2与切平面的交点
  341.                 Vector3 newVertice02 = GetLinePlaneCrossPoint(trianglePointCoord0, trianglePointCoord2);
  342.                 int index02 = IsContainsVertice(verticeList, newVertice02);
  343.                 if (index02 == -1 || !m_IsClearSamePoint)
  344.                 {
  345.                     verticeList.Add(newVertice02);
  346.                     index02 = verticeList.Count - 1;
  347.                     float k02 = 0;
  348.                     if (!IsEqual(newVertice02.x, trianglePointCoord0.x) && !IsEqual(trianglePointCoord2.x, trianglePointCoord0.x))
  349.                     {
  350.                         k02 = (newVertice02.x - trianglePointCoord0.x) / (trianglePointCoord2.x - trianglePointCoord0.x);
  351.                     }
  352.                     else if(!IsEqual(newVertice02.y, trianglePointCoord0.y) && !IsEqual(trianglePointCoord2.y, trianglePointCoord0.y))
  353.                     {
  354.                         k02 = (newVertice02.y - trianglePointCoord0.y) / (trianglePointCoord2.y - trianglePointCoord0.y);
  355.                     }
  356.                     else
  357.                     {
  358.                         k02 = (newVertice02.z - trianglePointCoord0.z) / (trianglePointCoord2.z - trianglePointCoord0.z);
  359.                     }
  360.                     if (uvList.Count > 0)
  361.                     {
  362.                         Vector2 uv0 = uvList[trianglePointIndex0];
  363.                         Vector2 uv2 = uvList[trianglePointIndex2];
  364.  
  365.                         float newUV_x = (uv2.x - uv0.x) * k02 + uv0.x;
  366.                         float newUV_y = (uv2.y - uv0.y) * k02 + uv0.y;
  367.                         uvList.Add(new Vector2(newUV_x, newUV_y));
  368.                         Debug.Log("纹理坐标" + uvList[uvList.Count - 1]);
  369.                     }
  370.                     //法向量
  371.                     Vector3 normalX0 = normalList[trianglePointIndex0];
  372.                     Vector3 normalX2 = normalList[trianglePointIndex2];
  373.                     float newNoramlX02 = (normalX2.x - normalX0.x) * k02 + normalX0.x;
  374.                     float newNoramlY02 = (normalX2.y - normalX0.y) * k02 + normalX0.y;
  375.                     float newNoramlZ02 = (normalX2.z - normalX0.z) * k02 + normalX0.z;
  376.                     normalList.Add(new Vector3(newNoramlX02, newNoramlY02, newNoramlZ02));
  377.                 }
  378.                 //插入顶点索引，以此构建新三角形
  379.  
  380.                 //{0}
  381.                 triangleList.Insert(triangleIndex + 1, index01);
  382.                 triangleList.Insert(triangleIndex + 2, index02);
  383.  
  384.                 triangleList.Insert(triangleIndex + 3, index01);
  385.                 //{1}
  386.                 //{2}
  387.  
  388.                 triangleList.Insert(triangleIndex + 6, trianglePointIndex2);
  389.                 triangleList.Insert(triangleIndex + 7, index02);
  390.                 triangleList.Insert(triangleIndex + 8, index01);
  391.                 triangleIndex += 9;
  392.             }
  393.             else
  394.             {
  395.                 triangleIndex += 3;
  396.             }
  397.         }
  398.         //Debug.Log("顶点数" + verticeList.Count);
  399.         //Debug.Log("顶点索引数" + triangleList.Count);
  400.  
  401.         //筛选出切割面两侧的顶点索引
  402.         List<int> triangles1 = new List<int>();
  403.         List<int> triangles2 = new List<int>();
  404.         for (int triangleIndex = 0; triangleIndex < triangleList.Count; triangleIndex += 3)
  405.         {
  406.             int trianglePoint0 = triangleList[triangleIndex];
  407.             int trianglePoint1 = triangleList[triangleIndex + 1];
  408.             int trianglePoint2 = triangleList[triangleIndex + 2];
  409.  
  410.             Vector3 point0 = verticeList[trianglePoint0];
  411.             Vector3 point1 = verticeList[trianglePoint1];
  412.             Vector3 point2 = verticeList[trianglePoint2];
  413.             //切割面
  414.             float dis0 = GetPointToClipPlaneDis(point0);
  415.             float dis1 = GetPointToClipPlaneDis(point1);
  416.             float dis2 = GetPointToClipPlaneDis(point2);
  417.  
  418.             if ((dis0 < 0 || IsEqual(dis0, 0)) && (dis1 < 0 || IsEqual(dis1, 0)) && (dis2 < 0 || IsEqual(dis2, 0)))
  419.             {
  420.                 triangles1.Add(trianglePoint0);
  421.                 triangles1.Add(trianglePoint1);
  422.                 triangles1.Add(trianglePoint2);
  423.             }
  424.             else
  425.             {
  426.                 triangles2.Add(trianglePoint0);
  427.                 triangles2.Add(trianglePoint1);
  428.                 triangles2.Add(trianglePoint2);
  429.             }
  430.         }
  431.  
  432.         //新生顶点数
  433.         int newVerticeCount = verticeList.Count - verticeCount;
  434.         //再次添加一遍新增顶点，用于缝合切口
  435.         for (int newVerticeIndex = 0; newVerticeIndex < newVerticeCount; ++newVerticeIndex)
  436.         {
  437.             Vector3 newVertice = verticeList[verticeCount + newVerticeIndex];
  438.             Vector3 qiekouVertice = new Vector3(newVertice.x, newVertice.y, newVertice.z);
  439.             verticeList.Add(qiekouVertice);
  440.             //uv
  441.             if (uvList.Count > 0)
  442.             {
  443.                 Vector2 newUv = uvList[verticeCount + newVerticeIndex];
  444.                 Vector2 qiekouUv = new Vector3(0.99f, 0.99f);
  445.                 uvList.Add(qiekouUv);
  446.             }
  447.  
  448.  
  449.             //法线
  450.             Vector3 newNormal = normalList[verticeCount + newVerticeIndex];
  451.             Vector3 qiekouNormal = new Vector3(newNormal.x, newNormal.y, newNormal.z);
  452.             normalList.Add(qiekouNormal);
  453.         }
  454.         verticeCount = verticeCount + newVerticeCount;
  455.         //重新排序新生成的顶点,按照角度
  456.         List<SortAngle> SortAngleList = new List<SortAngle>();
  457.         for (int verticeIndex = verticeCount + 1; verticeIndex < verticeList.Count; verticeIndex++)
  458.         {
  459.             //计算角度,以0-1为参照
  460.             Vector3 vec1to0 = verticeList[verticeCount + 1] - verticeList[verticeCount];
  461.             Vector3 indexTo0 = verticeList[verticeIndex] - verticeList[verticeCount];
  462.  
  463.             float moIndexto0 = indexTo0.magnitude;
  464.             float mo1to0 = vec1to0.magnitude;
  465.             float dotRes = Vector3.Dot(indexTo0, vec1to0);
  466.             if (moIndexto0 == 0.0f)
  467.             {
  468.                 continue;
  469.             }
  470.             float angle = Mathf.Acos(dotRes / (mo1to0 * moIndexto0)); //Vector3.Angle(indexTo0.normalized, vec1to0.normalized);
  471.             bool isExis = false;
  472.             for (int i = 0; i < SortAngleList.Count; ++i)
  473.             {
  474.                 //同样角度，距离近的被剔除
  475.                 if (Mathf.Abs(SortAngleList[i].Angle * 180.0f / Mathf.PI - angle * 180.0f / Mathf.PI) < 0.1f)
  476.                 {
  477.                     float dis1 = Vector3.Distance(verticeList[SortAngleList[i].Index], verticeList[verticeCount]);
  478.                     float dis2 = Vector3.Distance(verticeList[verticeIndex], verticeList[verticeCount]);
  479.                     if (dis2 >= dis1)
  480.                     {
  481.                         SortAngleList[i].Index = verticeIndex;
  482.                     }
  483.                     isExis = true;
  484.                     break;
  485.                 }
  486.             }
  487.             if (!isExis)
  488.             {
  489.                 //Debug.Log(angle);
  490.                 SortAngle sortAngle = new SortAngle();
  491.                 sortAngle.Index = verticeIndex;
  492.                 sortAngle.Angle = angle;
  493.                 SortAngleList.Add(sortAngle);
  494.             }
  495.         }
  496.         SortAngleList.Sort();
  497.         //缝合切口
  498.         for (int verticeIndex = 0; verticeIndex < SortAngleList.Count - 1;)
  499.         {
  500.             triangles1.Add(SortAngleList[verticeIndex + 1].Index);
  501.             triangles1.Add(SortAngleList[verticeIndex].Index);
  502.             triangles1.Add(verticeCount);
  503.  
  504.             triangles2.Add(verticeCount);
  505.             triangles2.Add(SortAngleList[verticeIndex].Index);
  506.             triangles2.Add(SortAngleList[verticeIndex + 1].Index);
  507.  
  508.  
  509.             verticeIndex++;
  510.         }
  511.  
  512.         mf.mesh.vertices = verticeList.ToArray();
  513.         mf.mesh.triangles = triangles1.ToArray();
  514.         if (uvList.Count > 0)
  515.         {
  516.             mf.mesh.uv = uvList.ToArray();
  517.         }
  518.         mf.mesh.normals = normalList.ToArray();
  519.         //分割模型
  520.         GameObject newModel = new GameObject("New Model");
  521.         MeshFilter meshFilter = newModel.AddComponent<MeshFilter>();
  522.         meshFilter.mesh.vertices = mf.mesh.vertices;
  523.         meshFilter.mesh.triangles = triangles2.ToArray();
  524.         meshFilter.mesh.uv = mf.mesh.uv;
  525.         meshFilter.mesh.normals = mf.mesh.normals;
  526.         Renderer newRenderer = newModel.AddComponent<MeshRenderer>();
  527.         newRenderer.material = this.gameObject.GetComponent<MeshRenderer>().material;
  528.         newModel.transform.localPosition = transform.localPosition;
  529.         newModel.AddComponent<TouchToPlane>();
  530.     }
  531.  
  532.     float GetPointToClipPlaneDis(Vector3 point)
  533.     {
  534.         return Vector3.Dot((point - m_ClipPlanePoint), m_ClipPlaneNormal);
  535.     }
  536.  
  537.     Vector3 GetLinePlaneCrossPoint(Vector3 lineBegin, Vector3 lineEnd)
  538.     {
  539.         //Debug.Log("起点：" + lineBegin + "," + "终点：" + lineEnd);
  540.         float x = 0;
  541.         float y = 0;
  542.         float z = 0;
  543.         float offsetZ = lineEnd.z - lineBegin.z;
  544.         float offsetY = lineEnd.y - lineBegin.y;
  545.         if (offsetZ != 0)
  546.         {
  547.             float k1 = (m_ClipPlaneNormal.x * (lineEnd.x - lineBegin.x) + m_ClipPlaneNormal.y * (lineEnd.y - lineBegin.y)) / offsetZ + m_ClipPlaneNormal.z;
  548.             float k2 = (m_ClipPlaneNormal.x * lineBegin.z * (lineEnd.x - lineBegin.x) + m_ClipPlaneNormal.y * lineBegin.z * (lineEnd.y - lineBegin.y)) / offsetZ;
  549.             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;
  550.             z = (k2 - k3) / k1;
  551.             x = (z - lineBegin.z) * (lineEnd.x - lineBegin.x) / offsetZ + lineBegin.x;
  552.             y = (z - lineBegin.z) * (lineEnd.y - lineBegin.y) / offsetZ + lineBegin.y;
  553.         }
  554.         else if(offsetY != 0)
  555.         {
  556.             z = lineBegin.z;
  557.             float k1 = m_ClipPlaneNormal.y + m_ClipPlaneNormal.x * (lineEnd.x - lineBegin.x) / (lineEnd.y - lineBegin.y);
  558.             float k2 = m_ClipPlaneNormal.x * lineBegin.y * (lineEnd.x - lineBegin.x) / (lineEnd.y - lineBegin.y);
  559.             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;
  560.             y = (k2 - k3) / k1;
  561.             x = (y - lineBegin.y) * (lineEnd.x - lineBegin.x) / (lineEnd.y - lineBegin.y) + lineBegin.x;
  562.         }
  563.         else
  564.         {
  565.             z = lineBegin.z;
  566.             y = lineBegin.y;
  567.             x = (m_ClipPlaneNormal.x * m_ClipPlanePoint.x - m_ClipPlaneNormal.y * (y - m_ClipPlanePoint.y) - m_ClipPlaneNormal.z * (z - m_ClipPlanePoint.z)) / m_ClipPlaneNormal.x;
  568.         }
  569.  
  570.  
  571.  
  572.         // Debug.Log(x + "," + y + "," + z);
  573.         return new Vector3(x, y, z);
  574.     }
  575.  
  576.     int IsContainsVertice(List<Vector3> list, Vector3 vertice)
  577.     {
  578.         int count = list.Count;
  579.         for(int i = 0; i < count; ++i)
  580.         {
  581.             Vector3 ii = list[i];
  582.             if (IsEqual(ii.x, vertice.x) && IsEqual(ii.y, vertice.y) && IsEqual(ii.z, vertice.z))
  583.             {
  584.                 return i;
  585.             }
  586.         }
  587.  
  588.         return -1;
  589.     }
  590.  
  591.     bool IsEqual(float num1, float num2)
  592.     {
  593.         float absX = Mathf.Abs(num1 - num2);
  594.         return absX < 0.00001f;
  595.     }
  596. }
  1. /*
  2.  * @authors: liangjian
  3.  * @desc:	
  4. */
  5. using UnityEngine;
  6. using System.Collections;
  7. using System;
  8.  
  9. public class SortAngle : IComparable<SortAngle> {
  10.     public int Index;
  11.     public float Angle;
  12.     public int CompareTo(SortAngle item)
  13.     {
  14.         return item.Angle.CompareTo(Angle);
  15.     }
  16. }














                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/98013
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号