精华内容
下载资源
问答
  • unity贝塞尔曲线
    千次阅读
    2020-11-26 16:34:38

    背景

    开发过程中有时会用到做贝塞尔曲线动画,单单有DoTween有时候达不到效果,此时可以采用此方案解决。扩展下,可以通过更换控制点,随机更多曲线动画。

    核心代码

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using DG.Tweening;
    
    public class TestBezier : MonoBehaviour
    {
        private float _times=3f;
        private float _pointCount = 5f;
        public GameObject obj;
        public GameObject startObj;
        public GameObject controlObj;
        public GameObject endObj;
       
        // Update is called once per frame
        void Update()
        {
            if (Input.GetKeyDown(KeyCode.A))
            {
                DoAnim();
            }
        }
        private void DoAnim()
        {
            obj.transform.position = startObj.transform.position;
            Vector3[] pathvec = Bezier2Path(startObj.transform.position, controlObj.transform.position, endObj.transform.position);
            obj.transform.DOPath(pathvec, _times);
        }
        //获取二阶贝塞尔曲线路径数组
        private  Vector3[] Bezier2Path(Vector3 startPos, Vector3 controlPos, Vector3 endPos)
        {
            Vector3[] path = new Vector3[(int)_pointCount];
            for (int i = 1; i <= _pointCount; i++)
            {
                float t = i / _pointCount;
                path[i - 1] = Bezier2(startPos, controlPos, endPos, t);
            }
            return path;
        }
        // 2阶贝塞尔曲线
        public static Vector3 Bezier2(Vector3 startPos, Vector3 controlPos, Vector3 endPos, float t)
        {
            return (1 - t) * (1 - t) * startPos + 2 * t * (1 - t) * controlPos + t * t * endPos;
        }
    
        // 3阶贝塞尔曲线
        public static Vector3 Bezier3(Vector3 startPos, Vector3 controlPos1, Vector3 controlPos2, Vector3 endPos, float t)
        {
            float t2 = 1 - t;
            return t2 * t2 * t2 * startPos
                + 3 * t * t2 * t2 * controlPos1
                + 3 * t * t * t2 * controlPos2
                + t * t * t * endPos;
        }
    }
    
    

    可参考以下链接理解贝塞尔曲线和公式:
    https://blog.csdn.net/cfan927/article/details/104649623/
    https://blog.csdn.net/weixin_42513339/article/details/83019610

    更多相关内容
  • Unity贝塞尔曲线工具

    2020-12-05 23:43:15
    通过控制控制的坐标点来快速生成贝塞尔坐标,并将生成的坐标保存为map.asset文件供Unity读取坐标。
  • Unity 贝塞尔曲线

    2020-06-29 23:56:25
    贝塞尔曲线是最基本的曲线,一般用在计算机 图形学和 图像处理。贝塞尔曲线可以用来创建平滑的曲线的道路、 弯曲的路径就像 祖玛游戏、 弯曲型的河流等。 贝塞尔曲线工具类: using System.Collections; using ...

    贝塞尔曲线是最基本的曲线,一般用在计算机 图形学和 图像处理。贝塞尔曲线可以用来创建平滑的曲线的道路、 弯曲的路径就像 祖玛游戏、 弯曲型的河流等。

    在这里插入图片描述

    贝塞尔曲线工具类:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class BezierUtils
    {
        /// <summary>
        /// 根据T值,计算贝塞尔曲线上面相对应的点
        /// </summary>
        /// <param name="t"></param>T值
        /// <param name="p0"></param>起始点
        /// <param name="p1"></param>控制点
        /// <param name="p2"></param>目标点
        /// <returns></returns>根据T值计算出来的贝赛尔曲线点
        private static Vector3 CalculateCubicBezierPoint(float t, Vector3 p0, Vector3 p1, Vector3 p2)
        {
            float u = 1 - t;
            float tt = t * t;
            float uu = u * u;
    
            Vector3 p = uu * p0;
            p += 2 * u * t * p1;
            p += tt * p2;
    
            return p;
        }
    
        /// <summary>
        /// 获取存储贝塞尔曲线点的数组
        /// </summary>
        /// <param name="startPoint"></param>起始点
        /// <param name="controlPoint"></param>控制点
        /// <param name="endPoint"></param>目标点
        /// <param name="segmentNum"></param>采样点的数量
        /// <returns></returns>存储贝塞尔曲线点的数组
        public static Vector3[] GetBeizerList(Vector3 startPoint, Vector3 controlPoint, Vector3 endPoint, int segmentNum)
        {
            Vector3[] path = new Vector3[segmentNum];
            for (int i = 1; i <= segmentNum; i++)
            {
                float t = i / (float)segmentNum;
                Vector3 pixel = CalculateCubicBezierPoint(t, startPoint,
                    controlPoint, endPoint);
                path[i - 1] = pixel;
                Debug.Log(path[i - 1]);
            }
            return path;
    
        }
    }
    

    贝塞尔曲线的用法:

    //using UnityEngine;
    //using System.Collections.Generic;
    //[RequireComponent(typeof(LineRenderer))]
    //public class Bezier : MonoBehaviour
    //{
    //    public Transform[] controlPoints;
    //    public LineRenderer lineRenderer;
    
    //    private int layerOrder = 0;
    //    private int _segmentNum = 5000;
    
    
    //    void Start()
    //    {
    //        if (!lineRenderer)
    //        {
    //            lineRenderer = GetComponent<LineRenderer>();
    //        }
    //        lineRenderer.sortingLayerID = layerOrder;
    //    }
    
    //    void Update()
    //    {
    
    //        DrawCurve();
    
    //    }
    
    //    void DrawCurve()
    //    {
    //        for (int i = 1; i <= _segmentNum; i++)
    //        {
    //            float t = i / (float)_segmentNum;
    //            int nodeIndex = 0;
    //            Vector3 pixel = CalculateCubicBezierPoint(t, controlPoints[nodeIndex].position,
    //                controlPoints[nodeIndex + 1].position, controlPoints[nodeIndex + 2].position);
    //            lineRenderer.positionCount = i;
    //            lineRenderer.SetPosition(i - 1, pixel);
    //        }
    
    //    }
    
    //    Vector3 CalculateCubicBezierPoint(float t, Vector3 p0, Vector3 p1, Vector3 p2)
    //    {
    //        float u = 1 - t;
    //        float tt = t * t;
    //        float uu = u * u;
    
    //        Vector3 p = uu * p0;
    //        p += 2 * u * t * p1;
    //        p += tt * p2;
    
    //        return p;
    //    }
    
    //}
    
    using UnityEngine;
    using System.Collections.Generic;
    [RequireComponent(typeof(LineRenderer))]
    public class Bezier : MonoBehaviour
    {
        public Transform[] controlPoints;
        public LineRenderer lineRenderer;
    
        private int curveCount = 0;
        private int layerOrder = 0;
        private int SEGMENT_COUNT = 50;
    
    
        void Start()
        {
            if (!lineRenderer)
            {
                lineRenderer = GetComponent<LineRenderer>();
            }
            lineRenderer.sortingLayerID = layerOrder;
            curveCount = (int)controlPoints.Length / 3;
        }
    
        void Update()
        {
    
            DrawCurve();
    
        }
    
        void DrawCurve()
        {
            for (int j = 0; j < curveCount; j++)
            {
                for (int i = 1; i <= SEGMENT_COUNT; i++)
                {
                    float t = i / (float)SEGMENT_COUNT;
                    int nodeIndex = j * 3;
                    Vector3 pixel = CalculateCubicBezierPoint(t, controlPoints[nodeIndex].position, controlPoints[nodeIndex + 1].position, controlPoints[nodeIndex + 2].position, controlPoints[nodeIndex + 3].position);
                    lineRenderer.SetVertexCount(((j * SEGMENT_COUNT) + i));
                    lineRenderer.SetPosition((j * SEGMENT_COUNT) + (i - 1), pixel);
                }
    
            }
        }
    
        Vector3 CalculateCubicBezierPoint(float t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3)
        {
            float u = 1 - t;
            float tt = t * t;
            float uu = u * u;
            float uuu = uu * u;
            float ttt = tt * t;
    
            Vector3 p = uuu * p0;
            p += 3 * uu * t * p1;
            p += 3 * u * tt * p2;
            p += ttt * p3;
    
            return p;
        }
    }
    
    展开全文
  • unity 贝塞尔曲线和Dotween配合的具体应用,可以配合你
  • 常用的贝塞尔曲线,就是二维图形应用程序的数学曲线。曲线定义起始点、终止点、控制点。通过调整控制点,贝塞尔曲线的形状会发生变化。日常常用的就是三阶,即四个点确定一条曲线。目的是通过贝塞尔曲线,得到曲线上...

    Unity 贝塞尔曲线的创建

    效果

    请添加图片描述

    贝塞尔曲线原理

    常用的贝塞尔曲线,就是二维图形应用程序的数学曲线。 曲线定义:起始点、终止点、控制点。通过调整控制点,贝塞尔曲线的形状会发生变化。

    一阶直线

    如何将下图中 C C C点在设定时间内,从 A A A点移动到 B B B点?这里设定一个时间 t , t ∈ ( 0 , 1 ) t ,t \in(0,1) t,t(0,1),

    设定 t t t时间内 O A ⃗ \vec{OA} OA 等比缩短成 O E ⃗ \vec{OE} OE , O B ⃗ \vec{OB} OB 的单位向量延长到 O F ⃗ \vec{OF} OF
    O E ⃗ = O A ⃗ ( 1 − t ) \vec{OE}=\vec{OA}(1-t) OE =OA (1t)
    O F ⃗ = O B ⃗ × t \vec{OF}=\vec{OB}\times t OF =OB ×t
    O C ⃗ = O A ⃗ ( 1 − t ) + O B ⃗ × t \vec{OC}=\vec{OA}(1-t)+\vec{OB}\times t OC =OA (1t)+OB ×t

    这样就可以得到 C C C点在设定时间内,从 A A A点移动到 B B B点的插值。

     Vector3 AB = (1 - t) * OA + t * OB;
    

    二阶曲线

    二阶是基于一阶的算法,也就是分别处理 A B ⃗ \vec{AB} AB B C ⃗ \vec{BC} BC

     Vector3 AB = (1 - t) * OA + t * OB;
     Vector3 BC = (1 - t) * OB + t * OC;
    

    再将 A B ⃗ \vec{AB} AB B C ⃗ \vec{BC} BC 也进行一阶的算法处理

     Vector3 ABC = (1 - t) * AB + t * BC;
    

    三阶曲线

    三阶和二价类似,不断累加。

       Vector3 AB = (1 - t) * OA + t * OB;
       Vector3 BC = (1 - t) * OB + t * OC;
       Vector3 CD = (1 - t) * OC + t * OD;
    
       Vector3 ABC = (1 - t) * AB + t * BC;
       Vector3 BCD = (1 - t) * BC + t * CD;
    
       result = (1 - t) * ABC + t * BCD;
    

    后面四道高阶以此类推。日常常用的就是三阶,即四个点确定一条曲线。

    在unity中的应用

    目的是通过贝塞尔曲线,得到曲线上的点位,以便建立运动路径数据。

    通过界面的编辑扩展工具,建立贝塞尔工具。

    #if UNITY_EDITOR
        public class BesselPathCreat : ScriptableWizard
        {
            public string Name = "Path";
            // 点的半径
            public float radius = 1;
            // 曲线取点的密度
            public int densityCurve = 1;
            /// <summary>
            /// 绘制曲线控制点 -- 此脚本的子物体
            /// </summary>
            public List<GameObject> PathPointList = new List<GameObject>();
    
            DrawGizmosLine drawGizmosLint;
            GameObject game;
    
            [MenuItem("FrameWorkSong//FrameWork/3.创建贝塞尔路径", false, 3)]
            static void CreateBasselPath()
            {
                ScriptableWizard.DisplayWizard<BesselPathCreat>("CreateBasselPath", "创建", "加点");
    
            }
            /// <summary>
            /// 创建按钮触发
            /// </summary>
            void OnWizardCreate()
            {
                if (PathPointList.Count > 4)
                {
                    var level = ScriptableObject.CreateInstance<BasselPathTemplet>();
                    level.BasselPathPoints = drawGizmosLint.CurvePoints;
                    AssetDatabase.CreateAsset(level, @"Assets/FrameWorkSong/Data/" + Name + ".asset");//在传入的路径中创建资源
                    AssetDatabase.SaveAssets(); //存储资源
                    AssetDatabase.Refresh(); //刷新
    
                }
    
    
                DestroyObject();
            }
            /// <summary>
            /// 关闭触发
            /// </summary>
            void DestroyObject()
            {
                if (game)
                {
                    DestroyImmediate(game);
                }
                for (int i = 0; i < PathPointList.Count; i++)
                {
                    DestroyImmediate(PathPointList[i]);
                }
            }
            void OnWizardUpdate()
            {
                
            }
            /// <summary>
            /// 加点按钮触发
            /// </summary>
            // When the user presses the "Apply" button OnWizardOtherButton is called.
            void OnWizardOtherButton()
            {
    
                if (PathPointList.Count == 0)
                {
                    game = new GameObject();
                    drawGizmosLint = game.AddComponent<DrawGizmosLine>();
                }
                BasselPath basselPath = new BasselPath();
                DrawGizmosPointLine drawGizmos = basselPath.MianPiont.AddComponent<DrawGizmosPointLine>();
                PathPointList.Add(basselPath.FrontPiont);
                PathPointList.Add(basselPath.MianPiont);
                PathPointList.Add(basselPath.BackePiont);
                drawGizmos.SelfPoint = basselPath.Piont;
                drawGizmosLint.SelfPoint = PathPointList;
                drawGizmosLint.densityCurve = densityCurve;
                drawGizmosLint.radius = radius;
            }
            void OnDestroy()
            {
                DestroyObject();
            }
    
    
        }
    #endif
    

    这里用到了,类派生以创建编辑器向导。详情可以查阅官方api https://docs.unity3d.com/cn/current/ScriptReference/ScriptableWizard.html

    贝塞尔的创建方法

     public class BasselPath
        {
            List<GameObject> piont = new List<GameObject>();
            GameObject mianPiont;
            GameObject frontPiont;
            GameObject backePiont;
            public BasselPath()
            {
                mianPiont = new GameObject();
                mianPiont.transform.position = Vector3.zero;
                frontPiont = new GameObject();
                frontPiont.transform.position = Vector3.zero + (Vector3.right * 5);
    
                backePiont = new GameObject();
                backePiont.transform.position = Vector3.zero + (Vector3.left * 5);
    
                piont.Add(frontPiont);
                piont.Add(mianPiont);
                piont.Add(backePiont);
                backePiont.transform.SetParent(mianPiont.transform);
                frontPiont.transform.SetParent(mianPiont.transform);
                mianPiont.AddComponent<DrawGizmosPoint>();
                frontPiont.AddComponent<DrawGizmosPoint>();
                backePiont.AddComponent<DrawGizmosPoint>();
            }
    
            public GameObject MianPiont { get => mianPiont; set => mianPiont = value; }
            public GameObject FrontPiont { get => frontPiont; }
            public GameObject BackePiont { get => backePiont; }
            public List<GameObject> Piont { get => piont; }
        }
    
    
    
        /// <summary>
        /// 绘制节点
        /// </summary>
        public class DrawGizmosPoint : MonoBehaviour
        {
            public float radius = 1;
            private void OnDrawGizmos()
            {
                //绘制点
                Gizmos.color = Color.blue;
                Gizmos.DrawSphere(transform.position, radius * 0.5f);
            }
        }
        /// <summary>
        /// 绘制节点线
        /// </summary>
        public class DrawGizmosPointLine : MonoBehaviour
        {
            public float radius = 1;
            public List<GameObject> SelfPoint = new List<GameObject>();
            private void OnDrawGizmos()
            {
                List<Vector3> controlPointPos = SelfPoint.Select(point => point.transform.position).ToList();
    
    
    
                //绘制曲线控制点连线
                Gizmos.color = Color.red;
                for (int i = 0; i < controlPointPos.Count - 1; i += 3)
                {
                    Gizmos.DrawLine(controlPointPos[i], controlPointPos[i + 1]);
                    Gizmos.DrawLine(controlPointPos[i + 1], controlPointPos[i + 2]);
                }
            }
        }
        /// <summary>
        /// 绘制曲线
        /// </summary>
        public class DrawGizmosLine : MonoBehaviour
        {
            public float radius;
            public int densityCurve;
            public List<GameObject> SelfPoint;
            public List<Vector3> CurvePoints;
            private void OnDrawGizmos()
            {
                List<Vector3> controlPointPos = SelfPoint.Select(point => point.transform.position).ToList();
                if (controlPointPos != null)
                {
                    CurvePoints = GetDrawingPoints(controlPointPos, densityCurve);
                }
    
                //绘制曲线
                if (CurvePoints.Count >= 4)
                {
                    Gizmos.color = Color.green;
                    //点密度
                    foreach (var item in CurvePoints)
                    {
                        Gizmos.DrawSphere(item, radius * 0.5f);
                    }
                    //曲线
                    for (int i = 0; i < CurvePoints.Count - 1; i++)
                    {
                        Gizmos.DrawLine(CurvePoints[i], CurvePoints[i + 1]);
                    }
                }
    
    
            }
            /// <summary>
            /// 获取绘制点
            /// </summary>
            /// <param name="controlPoints"></param>
            /// <param name="segmentsPerCurve"></param>
            /// <returns></returns>
            public List<Vector3> GetDrawingPoints(List<Vector3> controlPoints, int segmentsPerCurve)
            {
                List<Vector3> points = new List<Vector3>();
                // 下一段的起始点和上段终点是一个,所以是 i+=3
                for (int i = 1; i < controlPoints.Count - 4; i += 3)
                {
    
                    var p0 = controlPoints[i];
                    var p1 = controlPoints[i + 1];
                    var p2 = controlPoints[i + 2];
                    var p3 = controlPoints[i + 3];
                    float dis = Vector3.Distance(p0, p3);
                    int count = Mathf.CeilToInt(segmentsPerCurve * dis);
                    if (count < segmentsPerCurve)
                    {
                        count = segmentsPerCurve;
                    }
    
                    for (int j = 0; j <= count; j++)
                    {
                        var t = j / (float)count;
                        points.Add(CalculateBezierPoint(t, p0, p1, p2, p3));
                    }
                }
                return points;
            }
            // 三阶公式
            Vector3 CalculateBezierPoint(float t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3)
            {
                Vector3 result;
    
                Vector3 p0p1 = (1 - t) * p0 + t * p1;
                Vector3 p1p2 = (1 - t) * p1 + t * p2;
                Vector3 p2p3 = (1 - t) * p2 + t * p3;
    
                Vector3 p0p1p2 = (1 - t) * p0p1 + t * p1p2;
                Vector3 p1p2p3 = (1 - t) * p1p2 + t * p2p3;
    
                result = (1 - t) * p0p1p2 + t * p1p2p3;
                return result;
            }
    
        }
    
    
    
    展开全文
  • 通过可视化的手柄旋转改变曲线,可打断手柄,可增加控制点
  • Unity 贝塞尔曲线制作迁徙图

    千次阅读 2021-09-26 10:12:46
    贝塞尔曲线是图形学中非常重要的参数曲线,在此不做详细介绍,这里我们用到的是二次方公式: using UnityEngine; using System.Collections.Generic; namespace SK.Framework { public static class Vector3...

    效果图:

     实现该效果图所需的知识点:

    1.贝塞尔曲线

    贝塞尔曲线是图形学中非常重要的参数曲线,在此不做详细介绍,这里我们用到的是二次方公式:

    using UnityEngine;
    using System.Collections.Generic;
    
    namespace SK.Framework
    {
        public static class Vector3Extension 
        {
            /// <summary>
            /// 生成贝塞尔曲线
            /// </summary>
            /// <param name="self">控制点</param>
            /// <param name="startPoint">贝塞尔曲线起点</param>
            /// <param name="endPoint">贝塞尔曲线终点</param>
            /// <param name="count">贝塞尔曲线点个数</param>
            /// <returns>组成贝塞尔曲线的点集合</returns>
            public static Vector3[] GenerateBeizer(this Vector3 self, Vector3 startPoint, Vector3 endPoint, int count)
            {
                Vector3[] retValue = new Vector3[count];
                for (int i = 1; i <= count; i++)
                {
                    float t = i / (float)count;
                    float u = 1 - t;
                    float tt = Mathf.Pow(t, 2);
                    float uu = Mathf.Pow(u, 2);
                    Vector3 point = uu * startPoint;
                    point += 2 * u * t * self;
                    point += tt * endPoint;
                    retValue[i - 1] = point;
                }
                return retValue;
            }      
        }
    }

    2.LineRenderer光线渲染器

    LineRenderer在Unity中应用于线段的渲染,通过设置线段各个点的位置实现线段的绘制。

    using UnityEngine;
    using SK.Framework;
    
    public class Foo : MonoBehaviour
    {
        private void Start()
        {
            //通过起点(0,0,0)、控制点(0,7,5)、终点(0,0,10)生成贝塞尔曲线各点
            Vector3[] points = new Vector3(0f, 7f, 5f).GenerateBeizer(Vector3.zero, new Vector3(0f, 0f, 10f), 100);
    
            gameObject.AddComponent<LineRenderer>()
                //设置材质
                .SetMaterial(Resources.Load<Material>("Arrow"))
                //设置线段点个数
                .SetPositionCount(points.Length)
                //设置线段各点
                .SetLinePositions(points)
                //设置贴图为平铺模式
                .SetTextureMode(LineTextureMode.Tile)
                //设置起始宽度
                .SetStartWidth(.5f)
                //设置结束宽度
                .SetEndWidth(.5f);
        }
    }

    上述代码中用到对LineRenderer类的拓展函数

    using UnityEngine;
    
    namespace SK.Framework
    {
        /// <summary>
        /// 光线渲染器相关拓展
        /// </summary>
        public static class LineRenderExtension
        {
            /// <summary>
            /// 设置起始宽度
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="width">起始宽度</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetStartWidth(this LineRenderer self, float width)
            {
                self.startWidth = width;
                return self;
            }
            /// <summary>
            /// 设置结束宽度
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="width">结束宽度</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetEndWidth(this LineRenderer self, float width)
            {
                self.endWidth = width;
                return self;
            }
            /// <summary>
            /// 设置起始颜色
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="color">起始颜色</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetStartColor(this LineRenderer self, Color color)
            {
                self.startColor = color;
                return self;
            }
            /// <summary>
            /// 设置结束颜色
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="color">结束颜色</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetEndColor(this LineRenderer self, Color color)
            {
                self.endColor = color;
                return self;
            }
            /// <summary>
            /// 设置点个数
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="count">点个数</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetPositionCount(this LineRenderer self, int count)
            {
                self.positionCount = count;
                return self;
            }
            /// <summary>
            /// 设置点位置
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="index">索引</param>
            /// <param name="position">位置</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetLinePosition(this LineRenderer self, int index, Vector3 position)
            {
                self.SetPosition(index, position);
                return self;
            }
            /// <summary>
            /// 设置点位置
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="positions">位置数组</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetLinePositions(this LineRenderer self, Vector3[] positions)
            {
                for (int i = 0; i < positions.Length; i++)
                {
                    self.SetPosition(i, positions[i]);
                }
                return self;
            }
            /// <summary>
            /// 设置是否循环(终点是否连接起点)
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="loop">是否循环</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetLoop(this LineRenderer self, bool loop)
            {
                self.loop = loop;
                return self;
            }
            /// <summary>
            /// 设置CornerVertices属性
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="cornerVertices">conner vertices</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetCornerVertices(this LineRenderer self, int cornerVertices)
            {
                self.numCornerVertices = cornerVertices;
                return self;
            }
            /// <summary>
            /// 设置EndCapVertices属性
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="endCapVertices">end cap vertices</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetEndCapVertices(this LineRenderer self, int endCapVertices)
            {
                self.numCapVertices = endCapVertices;
                return self;
            }
            /// <summary>
            /// 设置Alignment属性
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="alignment">alignment</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetAlignment(this LineRenderer self, LineAlignment alignment)
            {
                self.alignment = alignment;
                return self;
            }
            /// <summary>
            /// 设置TextureMode
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="textureMode">texture mode</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetTextureMode(this LineRenderer self, LineTextureMode textureMode)
            {
                self.textureMode = textureMode;
                return self;
            }
            /// <summary>
            /// 设置材质球
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="material">材质球</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer SetMaterial(this LineRenderer self, Material material)
            {
                self.material = material;
                return self;
            }
            /// <summary>
            /// 烘焙网格
            /// </summary>
            /// <param name="self">光线渲染器</param>
            /// <param name="mesh">网格</param>
            /// <returns>光线渲染器</returns>
            public static LineRenderer BakeMesh(this LineRenderer self, out Mesh mesh)
            {
                mesh = new Mesh();
                self.BakeMesh(mesh);
                return self;
            }
        }
    }

    3.UV滚动

    通过UV的滚动Shader实现箭头的移动,资源来源于他人博客:https://blog.csdn.net/u013354943/article/details/105414827/

    Shader "Custom/Arrow"
    {
        Properties
        {
            _MainTex ("Texture", 2D) = "white" {}
            _MSpeed("MoveSpeed", Range(1, 3)) = 2 //移动速度
        }
        SubShader
        {
            //贴图带透明通道 ,半透明效果设置如下:
            tags{"Queue" = "Transparent" "RenderType" = "Transparent" "IgnoreProjector" = "True"}
            LOD 100
            Blend  SrcAlpha OneMinusSrcAlpha           //Blend选值为: SrcAlpha 和1-SrcAlpha  //也可测试为 DstColor SrcColor    //one one    
            
            Pass
            {
                Name "Simple"
                Cull off //双面
    
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                // make fog work
                #pragma multi_compile_fog
    
                #include "UnityCG.cginc"
    
                struct appdata
                {
                    float4 vertex : POSITION;
                    float2 uv : TEXCOORD0;
                };
    
                struct v2f
                {
                    float2 uv : TEXCOORD0;
                    UNITY_FOG_COORDS(1)
                    float4 vertex : SV_POSITION;
                };
    
                sampler2D _MainTex;
                float4 _MainTex_ST;
                float _MSpeed;
                v2f vert (appdata v)
                {
                    v2f o;
                    o.vertex = UnityObjectToClipPos(v.vertex);
                    o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                    UNITY_TRANSFER_FOG(o,o.vertex);
                    return o;
                }
    
                half4 frag(v2f i) : SV_Target
                {
                    float2 uv = float2(i.uv.x - _MSpeed * _Time.y,i.uv.y); //箭头移动的计算
                    // sample the texture
                    fixed4 col = tex2D(_MainTex, uv);
                    // apply fog
                    UNITY_APPLY_FOG(i.fogCoord, col);
                    return col;
                }
                ENDCG
            }
        }
    }

    最后通过该Shader创建材质Arrow放于Resources文件夹,创建物体挂载Foo脚本运行即可。

    展开全文
  • Unity 贝塞尔曲线 优化画线平滑

    千次阅读 2022-01-19 16:24:54
    贝塞尔曲线 优化画线平滑 在代码中调用下面这个方法,传入自己所要平滑的曲线的点的List列表,BezierCheck()会计算出每2个点之间需要补充多少个贝塞尔补间的点。 private static Vector3 pos1; private static ...
  • 提供unity3d编辑器中利用c#绘制贝塞尔曲线的代码,有例子和代码,可修改
  • unity贝塞尔曲线

    千次阅读 2022-03-23 17:14:34
    //贝塞尔曲线顶点 [SerializeField] private Vector3 [] BezierPos = new Vector3 [] { new Vector3[ -160, 0, 80 ], new Vector3[ 0, 0, 0 ], new Vector3[ 160, 0, 80 ] }; // 支持四阶、三阶、二阶贝塞尔曲线 ...
  • 用于学习贝塞尔曲线原理,观察贝塞尔曲线。并初步了解曲线绘制方法。
  • Unity贝塞尔曲线: Unity-BezierCurves

    千次阅读 2019-04-16 14:53:10
    推荐使用贝塞尔曲线来实现,github上已经有人做好了这样的插件。 github地址:https://github.com/dbrizov/Unity-BezierCurves 创建曲线 菜单: GameObjects -> Create Other -> Bezier Curve 代...
  • https://www.jianshu.com/p/8f82db9556d2
  • unity 贝塞尔曲线算法

    千次阅读 2018-05-28 19:09:37
    在任意几个点坐标绘制出的一条曲线,就叫贝赛尔曲线。线性公式 等同于线性插值这个最简单,就是很普通的插值算法,给定p0,p1,t取值范围0到1 // 线性 Vector3 Bezier(Vector3 p0, Vector3 p1, float t) { return...
  • 贝塞尔曲线公式/// 0到1的值,0获取曲线的起点,1获得曲线的终点/// 曲线的起始位置/// 决定曲线形状的控制点/// 曲线的终点public static Vector3 GetBezierPoint(float t, Vector3 start, Vector3 center, Vector3...
  • unity插件
  • Unity贝塞尔曲线介绍和实际使用

    千次阅读 2021-01-10 00:36:12
    Unity 中对贝塞尔曲线的实战应用,制作可视化操作曲线工具,文末附工具源码链接~
  • 所以这里将用到贝塞尔曲线公式计算生成一条曲线以及生成一条曲线在Linerenderer中所需要多少个点位。 这里有篇博客将贝塞尔曲线的原理和推导公式都讲解的非常清楚,有兴趣可以了解下:...
  • unity贝塞尔曲线

    千次阅读 2021-08-19 17:13:32
    简介 什么是贝塞尔曲线 ...1、贝塞尔曲线,它的背后是一个数学函数,N阶可以理解为N次方的意思,我们也可以把三阶贝塞尔曲线叫做三次贝塞尔曲线。 2、二阶贝塞尔曲线就是在一阶贝塞尔曲线的基础上再求一次一阶
  • 完整的数学贝塞尔曲线 强大的实时性能 如果您喜欢SplineMesh,请花一些时间对的进行投票,这会很有帮助! 评论也很感激。 如何使用它? 在从资产商店中获取资产。 它包括文档,评论和完整的展示,并附有示例供您...
  • Unity生成贝塞尔曲线路劲

    千次阅读 2022-03-10 10:17:07
    Unity生成贝塞尔曲线路劲,正弦函数式
  • 贝塞尔曲线脚本,里面记录了二次和三次贝塞尔曲线公式,如果想要其他曲线效果可添加多次贝塞尔公式,这个可以网上查找 using System.Collections; using System.Collections.Generic; using UnityEngine; public...
  • 通常会选择使用贝塞尔曲线,可能有些人对贝塞尔曲线不怎么了解,所以下面这篇文章就给大家介绍下在游戏如何使用贝塞尔曲线的基本想法,一起来看看吧。贝塞尔曲线是最基本的曲线,一般用在计算机 图形学和 图像处理。...
  • Unity贝塞尔曲线实现抛物线运动
  • Unity贝塞尔曲线自定义图片组件

    千次阅读 2021-12-17 11:24:44
    如图所见,展现出来的功能组件很简单,就是一个继承了Image并且多加了几个变量的自定义组件,实现的就是右边将图片作为元素绘制成一条贝塞尔曲线。 控制点列表中的点数据我做的还不够智能,暂时用第一个和最后一个...
  • 在游戏中使用Tween+贝塞尔曲线实现一个抛物线的效果。 1、线性贝塞尔曲线公式: 给定点P0、P1,线性贝兹曲线只是一条两点之间的直线。这条线由下式给出: 2、二次贝塞尔曲线公式: 二次方贝兹曲线的路径由给...
  • Unity贝塞尔曲线的实现

    千次阅读 2019-03-08 10:33:11
    贝塞尔曲线是最基本的曲线,一般用在计算机 图形学和 图像处理。贝塞尔曲线可以用来创建平滑的曲线的道路、 弯曲的路径就像 祖玛游戏、 弯曲型的河流等。 一条贝塞尔曲线是由一组定义的控制点 P0到 Pn,在 n 调用...
  • 新建一个BezierCurve类,它包含三个点,同样定义Reset方法来初始化点的值,当绑定...这个类代表了一个二次贝塞尔曲线。1234567891011121314using UnityEngine;public class BezierCurve : MonoBehaviour {public Vec...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 719
精华内容 287
关键字:

unity贝塞尔曲线

友情链接: sciencemanageme.rar