unity 线绳管道纯代码创建方法

原创 已于 2022-05-06 17:29:19 修改 · 3.1k 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#unity #游戏引擎

于 2022-05-06 17:00:30 首次发布
本文详细介绍了如何在Unity中利用代码生成具有内切圆处理的3D管道模型。通过在路径点放置横截面并处理拐点，使用内切圆避免了拐点处截面的压缩变形，确保了截面的正确朝向。主要涉及路径线转换、网格点创建和网格生成等关键步骤，适合于Unity开发者进行3D场景构建和管线模拟。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

unity 线绳管道纯代码创建方法

实现效果

原理思路

管线是由多边形横截面和路径线组成，只要在路径点上放置横截面就可以得到管线的网格点，通过网格点就可以生成管线模型。

以上的思路在生成只有两个节点的路径时，是没有问题，但是在生成有拐点的路径时，就会出现拐点的截面朝向问题，不管横截面朝向前一点或者后一点都会压缩变形。所以针对拐点必须分段处理，这里引用了内切圆的方法，在前后两个线段直接加入内切圆，将原先的拐点替换为两个切点和切圆上的三点，从而形成的新路径。

如上图，原始路径为a→b→c；取内切圆后，路径改为a→e→f→g→h→i→c；这样截面的朝向刚好为内切圆的切线方向。

核心代码

截面圆的建立

这里可以设置段数和半径；

        #region 横切圆创建
        /// <summary>
        /// 得到管线横切圆
        /// </summary>
        /// <param name="Count">段数</param>
        /// <param name="R">半径</param>
        /// <returns></returns>
        Vector3[] CircularSection(int Count, float R)
        {
            Vector3[] vector3s = new Vector3[Count];
            float angle = 360 / Count;
            Vector3 vector3 = new Vector3(R, 0, 0);
            for (int i = 0; i < Count; i++)
            {
                //根据角度得到圆的分布点
                vector3s[i] = vector3.ToAngle(angle * i, Vector3.zero, Vector3.forward);
            }
            return vector3s;
        }
        #endregion

路径线的转换

得到的路径线是没有做内切处理的，这里将路径拐点转换为内切圆；

#region 得到3d线的中心路径
        /// <summary>
        /// 设置中心路径
        /// </summary>
        /// <param name="createPoint">路径点</param>
        /// <param name="createPoint">拐点半径</param>
        /// <returns></returns>
        List<PipePoint> SetPipePoint(Vector3[] createPoint,float  elbowR)
        {
            List<PipePoint> pipePoints = new List<PipePoint>();
            int length = createPoint.Length;
            for (int i = 0; i < length; i++)
            {
                if (i == 0)
                {
                    AddPipePoints(createPoint[i], createPoint[i + 1] - createPoint[i], ref pipePoints);
                }
                else if (i == length - 1)
                {
                    AddPipePoints(createPoint[i], createPoint[i] - createPoint[i - 1], ref pipePoints);
                }
                else
                {
                    GetElbowPoint(createPoint[i], createPoint[i - 1], createPoint[i + 1], elbowR, ref pipePoints);
                }
            }
            return pipePoints;
        }
        /// <summary>
        /// 增加管线点
        /// </summary>
        /// <param name="location"></param>
        /// <param name="direction"></param>
        void AddPipePoints(Vector3 location, Vector3 direction, ref List<PipePoint> pipePoints)
        {
            PipePoint pipePoint = new PipePoint();
            pipePoint.Location = location;
            pipePoint.Direction = direction;
            pipePoints.Add(pipePoint);
        }
        /// <summary>
        /// 得到内切点
        /// </summary>
        /// <param name="focus"></param>
        /// <param name="front"></param>
        /// <param name="back"></param>
        /// <param name="r">内切圆半径</param>
        void GetElbowPoint(Vector3 focus, Vector3 front, Vector3 back, float r, ref List<PipePoint> pipePoints)
        {
            //拐点前后向量
            Vector3 frontVec = focus - front;
            Vector3 backVec = back - focus;
            //得到前后切点
            Vector3 tangencyFront = ((frontVec.magnitude - r) * frontVec.normalized) + front;
            Vector3 tangencyBack = (r * backVec.normalized) + focus;
            //得到内切圆圆心
            Vector3 circulPoint = GetCirculPoint(focus, tangencyFront, tangencyBack);
            //得到拐点分段
            Vector3[] circulSection = GetCirculSection(focus, tangencyFront, tangencyBack, circulPoint);
            //得到两个切点向量的法线
            Vector3 normal = Vector3.Cross(frontVec, backVec).normalized;
            //增加管线点
            AddPipePoints(tangencyFront, GetDirection(tangencyFront, circulPoint, normal), ref pipePoints);
            int length = circulSection.Length;
            for (int i = 0; i < length; i++)
            {
                AddPipePoints(circulSection[i], GetDirection(circulSection[i], circulPoint, normal), ref pipePoints);
            }
            AddPipePoints(tangencyBack, GetDirection(tangencyBack, circulPoint, normal), ref pipePoints);
        }
        /// <summary>
        /// 得到切点在内切圆上的切线方向
        /// </summary>
        /// <param name="self"></param>
        /// <param name="circulPoint"></param>
        /// <param name="normal"></param>
        /// <returns></returns>
        Vector3 GetDirection(Vector3 self, Vector3 circulPoint, Vector3 normal)
        {
            Vector3 vector = circulPoint - self;
            return Vector3.Cross(vector, normal).normalized;
        }
        /// <summary>
        /// 得到管线拐点内切圆分段点
        /// </summary>
        /// <param name="focus">交点</param>
        /// <param name="tangency1">切点1</param>
        /// <param name="tangency2">切点2</param>
        /// <param name="circulPoint">切圆圆心</param>
        /// <returns></returns>
        Vector3[] GetCirculSection(Vector3 focus, Vector3 tangency1, Vector3 tangency2, Vector3 circulPoint)
        {
            Vector3 vector0 = tangency1 - circulPoint;
            Vector3 vector4 = tangency2 - circulPoint;
            float dis = vector0.magnitude;
            Vector3 vector2 = (vector0 + vector4).normalized * dis;
            Vector3 vector1 = (vector0 + vector2).normalized * dis;
            Vector3 vector3 = (vector4 + vector2).normalized * dis;
            Vector3[] vector3s = new Vector3[3];
            vector3s[0] = vector1 + circulPoint;
            vector3s[1] = vector2 + circulPoint;
            vector3s[2] = vector3 + circulPoint;
            return vector3s;
        }
        /// <summary>
        /// 得到管线拐点内切圆圆心
        /// </summary>
        /// <param name="focus">拐点</param>
        /// <param name="tangency1">切点1</param>
        /// <param name="tangency2">切点2</param>
        /// <returns></returns>
        Vector3 GetCirculPoint(Vector3 focus, Vector3 tangency1, Vector3 tangency2)
        {
            Vector3 vector1 = tangency1 - focus;
            Vector3 vector2 = tangency2 - focus;
            Vector3 vector0 = (vector1 + vector2).normalized;
            float angle = Vector3.Angle(vector1, vector0);
            float dis = vector1.magnitude / Mathf.Cos(angle * Mathf.Deg2Rad);
            return (vector0 * dis) + focus;
        }
        #endregion

创建网格点

将横截面和路径点结合，创建网格点

      #region 创建网格点
        Vector3[] CreateMeshPoint(List<PipePoint> pipePoint, Vector3[] circular)
        {
            int length = pipePoint.Count;
            int circularCount = circular.Length;
            Vector3[] meshPoint = new Vector3[length * circularCount];
            for (int i = 0; i < length; i++)
            {
                for (int j = 0; j < circularCount; j++)
                {
                    meshPoint[(i * circularCount) + j] = circular[j].FromToMoveRotation(pipePoint[i].Location, pipePoint[i].Direction);
                }
            }
            return meshPoint;
        }
        #endregion

网格创建

    #region 网格创建
        Mesh CreatMesh(List<PipePoint> pipePoints, Vector3[] meshPoint, Vector3[] circular)
        {
            Mesh mesh = new Mesh();
            int circularCount = circular.Length;
            mesh.vertices = meshPoint;
            mesh.triangles = GetTriangles(pipePoints, circularCount);
            mesh.uv = GetUV(pipePoints, circular);
            mesh.RecalculateNormals();
            mesh.RecalculateBounds();
            return mesh;
        }
        Vector2[] GetUV(List<PipePoint> pipePoints, Vector3[] circular)
        {
            int length = pipePoints.Count;
            int circularCount = circular.Length;
            Vector2[] uvs = new Vector2[(circularCount * length)];
            float lineDis = 0;
            float circularDis = Vector3.Distance(circular[0], circular[1]);
            int k = 0;
            for (int i = 0; i < length; i++)
            {
                if (i != 0)
                {
                    lineDis += Vector3.Distance(pipePoints[i].Location, pipePoints[i - 1].Location);
                }
                for (int j = 0; j < circularCount; j++)
                {
                    Vector2 vector2;
                    if (j%2!=0)
                    {
                         vector2 = new Vector2(circularDis, lineDis);
                    }
                    else
                    {
                         vector2 = new Vector2(0, lineDis);
                    }
                  
                    uvs[k] = vector2;
                    k+=1;
                }
            }
            return uvs;
        }
        int[] GetTriangles(List<PipePoint> pipePoints, int Count)
        {
            int length = pipePoints.Count;
            int[] triangles = new int[(Count * (length - 1)) * 6];
            int k = 0;
            for (int i = 0; i < length - 1; i++)
            {
                for (int j = 0; j < Count; j++)
                {
                    if (j == Count - 1)
                    {
                        triangles[k] = (i * Count) + j;
                        triangles[k + 1] = (i * Count) + 0;
                        triangles[k + 2] = ((i + 1) * Count) + 0;
                        triangles[k + 3] = (i * Count) + j;
                        triangles[k + 4] = ((i + 1) * Count) + 0;
                        triangles[k + 5] = ((i + 1) * Count) + j;
                    }
                    else
                    {
                        triangles[k] = (i * Count) + j;
                        triangles[k + 1] = (i * Count) + j + 1;
                        triangles[k + 2] = ((i + 1) * Count) + j + 1;
                        triangles[k + 3] = (i * Count) + j;
                        triangles[k + 4] = ((i + 1) * Count) + j + 1;
                        triangles[k + 5] = ((i + 1) * Count) + j;
                    }
                    k += 6;
                }
            }
            return triangles;
        }
        #endregion

最后创建线

       public GameObject CreateLine(Vector3[] createPoint, Material material, int circularCount, float circularR, float elbowR)
        {
            GameObject game = new GameObject();
            MeshFilter filter = game.AddComponent<MeshFilter>();
            Vector3[] circul = CircularSection(circularCount, circularR);
            List<PipePoint> pipePoints = SetPipePoint(createPoint, elbowR);
            Vector3[] meshPoint = CreateMeshPoint(pipePoints, circul);
            filter.mesh = CreatMesh(pipePoints, meshPoint, circul);
            MeshRenderer renderer = game.AddComponent<MeshRenderer>();
            renderer.sharedMaterial = material;
            return game;
        }

Demo下载地址

【Unity3D小功能】Unity3D中在创建完项目后自动创建文件夹列表
优快云博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
03-20 4043
随着项目开发的体量增大，要导入大量的素材、UI、模型之类的资源。需要创建不同的文件夹进行整理，便于管理。就写了一个小工具，在导入资源包的时候自动创建文件夹，这个包后期还可以增加常用的插件、代码的框架、数据类、单例类、工具类、已经实现的比较完善的功能等。目前，先实现导入资源自动创建文件夹的功能吧。
unity绘制管道_Unity Shader - 图形管道(The Graphics Pipeline)
weixin_39532421的博客
01-12 668
Unlit Shader 的数据流：Object Data -> appdata Struct -> Vertex Shader -> v2f Struct -> Fragment Shader -> Final ColorVertex Data Structure第一个结构体是 appdata，它对应于输入组装阶段。为了刷新记忆，这个 appdata 来自于最后一个...
Unity SRP 一：建立一个新管线
qq_45203507的博客
12-25 1085
Unity SRP
Unity3d 管道建模插件
01-22
Unity3d可以使用插件在场景中使用各种管道预设进行管道建模。
【Unity 绳索和线缆模拟工具】Rope Toolkit 内置了多种绳索行为模式，支持动态拉伸、弯曲、碰撞检测等功能，非常适合制作绳索攀爬、绳索桥、吊绳、绳索武器（如鞭子、绳索枪）等交互场景
最新发布
2403_88403568的博客
05-29 468
Rope Toolkit 是一款专为 Unity 设计的绳索和线缆模拟工具，提供高度可定制且物理逼真的绳索效果。插件内置了多种绳索行为模式，支持动态拉伸、弯曲、碰撞检测等功能，非常适合制作绳索攀爬、绳索桥、吊绳、绳索武器（如鞭子、绳索枪）等交互场景。
unity模型制作（六）：绘制一个管道
u014261855的博客
04-15 4892
（不重要的前言：该博文为系列博文，每一篇有前后文关系，例如基类、组件的集成，如果发现有陌生组件和基类，请查看前面文章，本系列文章单纯应用unity的mesh来绘制模型，并未使用任何三方插件，文章内容、代码都是纯手打，望支持） 一个管道有四个面，分别是顶面、地面、内侧面、外侧面，先看顶面： 这其实就是一个铰链，内边和外边的顶点个数是一样的，头尾重合，就能画出一个圆圈。 其他部位： 外圈为circle1，内圈为circle2 circle1和circle2组合成顶面，circle1和c
Unity3D LWRP轻量级渲染之构建SRP管线
真像大白阿的博客
09-29 534
LWRP 轻量级渲染 根据官方给出的PPT以及大致的说明 LWRP 是精简并且优化过的渲染管线、主要聚焦性能、针对移动平台 所以开坑 LWRP，至于HDRP这个主要用于高性能的主机和PC上，目前不做端游，暂不考虑 高性能和高一致性的PBR 新的Shader库 一次渲染多个实时光 可插入 Scriptable Render Passes 的 API Unity Test Version: 2019.3.0.f1 而 Scriptable Render Passes 是由C#代码来完成渲染管线的
unity3d 命名管道 demo
12-15
unity3d 命名管道示例，使用的是比较白痴的方式，同步通信。异步通信，没弄出来，mono这个阉割版的有些坑爹
unity绘制管道_【Unity Shader】渲染管线
weixin_39615991的博客
12-19 226
流程概述应用程序阶段应用程序阶段，使用高级编程语言(C、C++、JAVA 等)进行开发，主要和CPU、内存打交道，诸如碰撞检测、场景图建立、空间八叉树更新、视锥裁剪等经典算法都在此阶段执行。在该阶段的末端，几何体数据(顶点坐标、法向量、纹理坐标、纹理等)通过数据总线传送到图形硬件。几何阶段几何阶段，主要负责顶点坐标变换、光照、裁剪、投影以及屏幕映射，该阶段基于GPU进行运算，在该阶段的末端得到了经...
unity线绳管道纯代码创建Demo
05-06
详见：https://blog.youkuaiyun.com/dxs1990/article/details/124614171?spm=1001.2014.3001.5502
Unity学习笔记—通过代码创建GameObject三种方法
HappyToWork
02-05 5457
通过代码创建游戏物体的三种方法
关于在沙雕unity中，以代码创建sprite
qq_39511410的博客
08-24 2374
string sprite_path = "img/无标题"; //Application.dataPath + Debug.Log(sprite_path); Texture2D texture = Resources.Load(sprite_path) as Texture2D; SpriteRenderer spriteRendere...
【Unity】程序创建Mesh（一）Mesh网格、代码创建模型、顶点信息、三角形信息、MeshFilter、MeshRenderer
一个普普通通的游戏开发者
03-14 5257
首先三角形信息的数据格式是一个 int 类型的数组，数组中的每个元素就是三角形的一个顶点（顶点是可以共用的），这个数组每三个元素形成一个面，所以数组的长度通常是3的倍数。具体来说，如果我们按照逆时针顺序（从三角形的一个顶点开始，沿着边缘到下一个顶点，再到下一个，最后回到起始顶点）来定义三角形的顶点，那么当观察者站在三角形的“外部”时，这个面会朝向观察者，我们称之为“正面”或“前向面”。相反，如果顶点顺序是顺时针的，那么当观察者站在三角形的“外部”时，这个面会背向观察者，我们称之为“背面”或“后向面”。
Unity绳子线缆插件
11-05
此插件可用于模拟绳子，线缆等 里面有自带的demo可供学习，方便使用
MediaPipeUnityPlugin：运行MediaPipe图形的Unity插件
02-06
MediaPipe Unity插件 这是一个使用MediaPipe的Unity（2019.4.18f1）插件。 平台类 Linux桌面（在ArchLinux上测试） 安卓 的iOS macOS（仅CPU） Windows 10（仅限CPU，实验性） 先决条件 MediaPipe 请确保安装必需的软件包，并检查是否可以在计算机上运行官方演示。 OpenCV 默认情况下，假定OpenCV 3安装在/usr （例如/usr/lib/libopencv_core.so ）。 如果您的版本或路径不同，请编辑和 。 .NET核心 该项目使用协议缓冲区与MediaPipe进行通信，并且必须安装.
Unity塑料软管的实现
qq_41614248的博客
02-06 883
可弯曲软管的动态生成
探索 Unity 多进程构建管道：一个高效的游戏开发工具
gitblog_00099的博客
03-30 449
探索 Unity 多进程构建管道：一个高效的游戏开发工具 项目简介 在游戏开发领域，Unity 是一款广泛使用的引擎，而 是一个创新的项目，它旨在优化 Unity 的构建流程，通过多进程并行化处理，显著提高大规模项目的构建速度。这个项目由 JiangZHHHH 开发并维护，对于那些需要频繁迭代和构建大型 Unity 项目的开发者来说，这将是一个非常有价值的技术解决方案。 技术解析 并行化构建 U...
【Unity】管道流动模拟Shader
发布unity，三维模型的相关内容
02-20 5118
抽象模拟管道介质流动的效果，使用顶点片元着色器。可以调整管线光泽，颜色，流动方向，透明度，流动体粗细，流动速度和横断面。
unity绘制管道_【译文】unity可编程渲染管道#1——自定义管道
weixin_39532352的博客
12-19 798
前言Scriptable Render Pipeline定制流水线控制渲染创建管道资产和实例。剔除，过滤，排序，渲染。保持记忆清洁。提供良好的编辑体验。这是涵盖Unity可编写脚本的渲染系列教程的第一部分管道。本教程假设您首先完成了基础知识系列，并且已经完成了程序网格教程。渲染系列的前几部分也很有用。本教程使用Unity 2018.3.0f2。新渲染管道的诞生。1. 创建管道要渲染任何东西，Uni...
AddPipePoints
03-29
### 关于 `AddPipePoints` 方法 在 Unity 中，如果要实现线绳或管道的创建并结合贝塞尔曲线的功能，通常会涉及多个自定义类和方法来管理路径点（即 PipePoint 列表）。虽然未提供具体的 `AddPipePoints` 定义，但从上下文中可以推测其功能可能是向某个列表中添加新的路径点对象。 以下是基于引用内容以及常见实践的一个可能实现方式： #### 可能的 `AddPipePoints` 方法定义 此方法的作用是将一组路径点加入到现有的路径集合中。假设我们有一个名为 `PipeManager` 的类用于管理这些路径点，则该方法可如下实现： ```csharp public class PipeManager { public List<PipePoint> pipePoints = new List<PipePoint>(); /// <summary> /// 向路径点列表中添加新点。 /// </summary> /// <param name="location">位置</param> /// <param name="direction">方向</param> public void AddPipePoints(Vector3 location, Vector3 direction) { PipePoint newPoint = new PipePoint(); newPoint.Location = location; newPoint.Direction = direction; // 添加至列表 pipePoints.Add(newPoint); } } // 假设 PipePoint 是一个简单的数据结构 [System.Serializable] public class PipePoint { public Vector3 Location; // 路径点的位置 public Vector3 Direction; // 路径的方向矢量 } ``` 上述代码展示了如何通过 `AddPipePoints` 将一个新的路径点添加到 `pipePoints` 列表中[^1]。这一步骤对于后续调用 `CreateMeshPoint` 来构建网格至关重要[^2]。 --- #### 结合贝塞尔曲线动态生成路径点 为了更灵活地控制路径形状，可以通过贝塞尔曲线计算中间插值点，并将其作为输入传递给 `AddPipePoints` 方法。例如： ```csharp private void GenerateBezierPath() { List<Vector3> bezierPoints = CalculateBezierCurve(controlPoints); foreach (Vector3 point in bezierPoints) { // 计算每个点的方向（可以根据前后两点差值得到） Vector3 direction = GetDirectionForPoint(point, controlPoints); // 添加路径点 manager.AddPipePoints(point, direction); } } /// <summary> /// 根据控制点计算贝塞尔曲线上的点集。 /// </summary> List<Vector3> CalculateBezierCurve(List<Vector3> controlPoints) { List<Vector3> result = new List<Vector3>(); float tStep = 0.05f; for (float t = 0; t <= 1; t += tStep) { Vector3 interpolatedPoint = BezierInterpolation(t, controlPoints); result.Add(interpolatedPoint); } return result; } /// <summary> /// 获取某一点对应的方向。 /// </summary> Vector3 GetDirectionForPoint(Vector3 currentPoint, List<Vector3> points) { int index = points.IndexOf(currentPoint); if (index > 0 && index < points.Count - 1) { return (points[index + 1] - points[index - 1]).normalized; } else { return Vector3.forward; // 默认方向 } } /// <summary> /// 贝塞尔插值函数。 /// </summary> Vector3 BezierInterpolation(float t, List<Vector3> controlPoints) { int n = controlPoints.Count - 1; Vector3 result = Vector3.zero; for (int i = 0; i <= n; i++) { float coefficient = BinomialCoefficient(n, i) * Mathf.Pow(1 - t, n - i) * Mathf.Pow(t, i); result += coefficient * controlPoints[i]; } return result; } /// <summary> /// 组合计数器系数。 /// </summary> float BinomialCoefficient(int n, int k) { return Factorial(n) / (Factorial(k) * Factorial(n - k)); } /// <summary> /// 阶乘辅助函数。 /// </summary> float Factorial(int value) { float result = 1; for (int i = 1; i <= value; i++) { result *= i; } return result; } ``` 以上代码片段实现了从控制点生成平滑贝塞尔曲线的过程，并利用 `AddPipePoints` 动态扩展路径点列表。 --- ### 总结 - `AddPipePoints` 方法的核心作用在于维护路径点的数据结构，便于后续渲染逻辑处理。 - 如果需要支持复杂的路径形态，建议引入贝塞尔曲线算法以增强灵活性。 - 上述代码仅为一种可能实现方案；具体细节需根据实际项目需求调整。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小生云木

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值