Unity 进行曲线轨迹自定义，以及根据自定义曲线轨迹运动

1. 当你需要相机镜头根据特定轨迹运动。或者一些AI的特定轨迹运动的时候。就可以用到下面的脚本了

一下方法来自官方案例
直接代码喽。你需要做的就是，复制到你的项目中。拖在脚本上，你就知道他怎么用了。

一共两个脚本，一个是自定义轨迹的，另一个是使对象根据轨迹运动的。

1. 脚本WaypointCircuit 。自定义轨迹。把脚本拖在一个父级上面。然后在子级添加 轨迹对象作为轨迹 顶点。脚本上的按键Assign using all child objects按下之后。就会把子级对象 作为 曲线的每个顶点。然后生成曲线轨迹运动

   using System;
   using System.Collections;
   using UnityEngine;
   	#if UNITY_EDITOR
   using UnityEditor;
   
   	#endif
   
   namespace UnityStandardAssets.Utility
   {
       public class WaypointCircuit : MonoBehaviour
       {
           public WaypointList waypointList = new WaypointList();
           [SerializeField] private bool smoothRoute = true;
           private int numPoints;
           private Vector3[] points;
           private float[] distances;
   
       public float editorVisualisationSubsteps = 100;
       public float Length { get; private set; }
   
       public Transform[] Waypoints
       {
           get { return waypointList.items; }
       }
   
       //this being here will save GC allocs
       private int p0n;
       private int p1n;
       private int p2n;
       private int p3n;
   
       private float i;
       private Vector3 P0;
       private Vector3 P1;
       private Vector3 P2;
       private Vector3 P3;
   
       // Use this for initialization
       private void Awake()
       {
           if (Waypoints.Length > 1)
           {
               CachePositionsAndDistances();
           }
           numPoints = Waypoints.Length;
       }
   
   
       public RoutePoint GetRoutePoint(float dist)
       {
           // position and direction
           Vector3 p1 = GetRoutePosition(dist);
           Vector3 p2 = GetRoutePosition(dist + 0.1f);
           Vector3 delta = p2 - p1;
           return new RoutePoint(p1, delta.normalized);
       }
   
   
       public Vector3 GetRoutePosition(float dist)
       {
           int point = 0;
   
           if (Length == 0)
           {
               Length = distances[distances.Length - 1];
           }
   
           dist = Mathf.Repeat(dist, Length);
   
           while (distances[point] < dist)
           {
               ++point;
           }
   
   
           // get nearest two points, ensuring points wrap-around start & end of circuit
           p1n = ((point - 1) + numPoints)%numPoints;
           p2n = point;
   
           // found point numbers, now find interpolation value between the two middle points
   
           i = Mathf.InverseLerp(distances[p1n], distances[p2n], dist);
   
           if (smoothRoute)
           {
               // smooth catmull-rom calculation between the two relevant points
   
   
               // get indices for the surrounding 2 points, because
               // four points are required by the catmull-rom function
               p0n = ((point - 2) + numPoints)%numPoints;
               p3n = (point + 1)%numPoints;
   
               // 2nd point may have been the 'last' point - a dupe of the first,
               // (to give a value of max track distance instead of zero)
               // but now it must be wrapped back to zero if that was the case.
               p2n = p2n%numPoints;
   
               P0 = points[p0n];
               P1 = points[p1n];
               P2 = points[p2n];
               P3 = points[p3n];
   
               return CatmullRom(P0, P1, P2, P3, i);
           }
           else
           {
               // simple linear lerp between the two points:
   
               p1n = ((point - 1) + numPoints)%numPoints;
               p2n = point;
   
               return Vector3.Lerp(points[p1n], points[p2n], i);
           }
       }
   
   
       private Vector3 CatmullRom(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float i)
       {
           // comments are no use here... it's the catmull-rom equation.
           // Un-magic this, lord vector!
           return 0.5f*
                  ((2*p1) + (-p0 + p2)*i + (2*p0 - 5*p1 + 4*p2 - p3)*i*i +
                   (-p0 + 3*p1 - 3*p2 + p3)*i*i*i);
       }
   
   
       private void CachePositionsAndDistances()
       {
           // transfer the position of each point and distances between points to arrays for
           // speed of lookup at runtime
           points = new Vector3[Waypoints.Length + 1];
           distances = new float[Waypoints.Length + 1];
   
           float accumulateDistance = 0;
           for (int i = 0; i < points.Length; ++i)
           {
               var t1 = Waypoints[(i)%Waypoints.Length];
               var t2 = Waypoints[(i + 1)%Waypoints.Length];
               if (t1 != null && t2 != null)
               {
                   Vector3 p1 = t1.position;
                   Vector3 p2 = t2.position;
                   points[i] = Waypoints[i%Waypoints.Length].position;
                   distances[i] = accumulateDistance;
                   accumulateDistance += (p1 - p2).magnitude;
               }
           }
       }
   
   
       private void OnDrawGizmos()
       {
           DrawGizmos(false);
       }
   
   
       private void OnDrawGizmosSelected()
       {
           DrawGizmos(true);
       }
   
   
       private void DrawGizmos(bool selected)
       {
           waypointList.circuit = this;
           if (Waypoints.Length > 1)
           {
               numPoints = Waypoints.Length;
   
               CachePositionsAndDistances();
               Length = distances[distances.Length - 1];
   
               Gizmos.color = selected ? Color.yellow : new Color(1, 1, 0, 0.5f);
               Vector3 prev = Waypoints[0].position;
               if (smoothRoute)
               {
                   for (float dist = 0; dist < Length; dist += Length/editorVisualisationSubsteps)
                   {
                       Vector3 next = GetRoutePosition(dist + 1);
                       Gizmos.DrawLine(prev, next);
                       prev = next;
                   }
                   Gizmos.DrawLine(prev, Waypoints[0].position);
               }
               else
               {
                   for (int n = 0; n < Waypoints.Length; ++n)
                   {
                       Vector3 next = Waypoints[(n + 1)%Waypoints.Length].position;
                       Gizmos.DrawLine(prev, next);
                       prev = next;
                   }
               }
           }
       }
   
   
       [Serializable]
       public class WaypointList
       {
           public WaypointCircuit circuit;
           public Transform[] items = new Transform[0];
       }
   
       public struct RoutePoint
       {
           public Vector3 position;
           public Vector3 direction;
   
   
           public RoutePoint(Vector3 position, Vector3 direction)
           {
               this.position = position;
               this.direction = direction;
           }
       }
   }
   }
   
   namespace UnityStandardAssets.Utility.Inspector
   {
   	#if UNITY_EDITOR
       [CustomPropertyDrawer(typeof (WaypointCircuit.WaypointList))]
       public class WaypointListDrawer : PropertyDrawer
       {
           private float lineHeight = 18;
           private float spacing = 4;
   
   
       public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
       {
           EditorGUI.BeginProperty(position, label, property);
   
           float x = position.x;
           float y = position.y;
           float inspectorWidth = position.width;
   
           // Draw label
   
   
           // Don't make child fields be indented
           var indent = EditorGUI.indentLevel;
           EditorGUI.indentLevel = 0;
   
           var items = property.FindPropertyRelative("items");
           var titles = new string[] {"Transform", "", "", ""};
           var props = new string[] {"transform", "^", "v", "-"};
           var widths = new float[] {.7f, .1f, .1f, .1f};
           float lineHeight = 18;
           bool changedLength = false;
           if (items.arraySize > 0)
           {
               for (int i = -1; i < items.arraySize; ++i)
               {
                   var item = items.GetArrayElementAtIndex(i);
   
                   float rowX = x;
                   for (int n = 0; n < props.Length; ++n)
                   {
                       float w = widths[n]*inspectorWidth;
   
                       // Calculate rects
                       Rect rect = new Rect(rowX, y, w, lineHeight);
                       rowX += w;
   
                       if (i == -1)
                       {
                           EditorGUI.LabelField(rect, titles[n]);
                       }
                       else
                       {
                           if (n == 0)
                           {
                               EditorGUI.ObjectField(rect, item.objectReferenceValue, typeof (Transform), true);
                           }
                           else
                           {
                               if (GUI.Button(rect, props[n]))
                               {
                                   switch (props[n])
                                   {
                                       case "-":
                                           items.DeleteArrayElementAtIndex(i);
                                           items.DeleteArrayElementAtIndex(i);
                                           changedLength = true;
                                           break;
                                       case "v":
                                           if (i > 0)
                                           {
                                               items.MoveArrayElement(i, i + 1);
                                           }
                                           break;
                                       case "^":
                                           if (i < items.arraySize - 1)
                                           {
                                               items.MoveArrayElement(i, i - 1);
                                           }
                                           break;
                                   }
                               }
                           }
                       }
                   }
   
                   y += lineHeight + spacing;
                   if (changedLength)
                   {
                       break;
                   }
               }
           }
           else
           {
               // add button
               var addButtonRect = new Rect((x + position.width) - widths[widths.Length - 1]*inspectorWidth, y,
                                            widths[widths.Length - 1]*inspectorWidth, lineHeight);
               if (GUI.Button(addButtonRect, "+"))
               {
                   items.InsertArrayElementAtIndex(items.arraySize);
               }
   
               y += lineHeight + spacing;
           }
   
           // add all button
           var addAllButtonRect = new Rect(x, y, inspectorWidth, lineHeight);
           if (GUI.Button(addAllButtonRect, "Assign using all child objects"))
           {
               var circuit = property.FindPropertyRelative("circuit").objectReferenceValue as WaypointCircuit;
               var children = new Transform[circuit.transform.childCount];
               int n = 0;
               foreach (Transform child in circuit.transform)
               {
                   children[n++] = child;
               }
               Array.Sort(children, new TransformNameComparer());
               circuit.waypointList.items = new Transform[children.Length];
               for (n = 0; n < children.Length; ++n)
               {
                   circuit.waypointList.items[n] = children[n];
               }
           }
           y += lineHeight + spacing;
   
           // rename all button
           var renameButtonRect = new Rect(x, y, inspectorWidth, lineHeight);
           if (GUI.Button(renameButtonRect, "Auto Rename numerically from this order"))
           {
               var circuit = property.FindPropertyRelative("circuit").objectReferenceValue as WaypointCircuit;
               int n = 0;
               foreach (Transform child in circuit.waypointList.items)
               {
                   child.name = "Waypoint " + (n++).ToString("000");
               }
           }
           y += lineHeight + spacing;
   
           // Set indent back to what it was
           EditorGUI.indentLevel = indent;
           EditorGUI.EndProperty();
       }
   
   
       public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
       {
           SerializedProperty items = property.FindPropertyRelative("items");
           float lineAndSpace = lineHeight + spacing;
           return 40 + (items.arraySize*lineAndSpace) + lineAndSpace;
       }
   
   
       // comparer for check distances in ray cast hits
       public class TransformNameComparer : IComparer
       {
           public int Compare(object x, object y)
           {
               return ((Transform) x).name.CompareTo(((Transform) y).name);
           }
       }
   }
    #endif
   }
   
   

2. 脚本WaypointProgressTracker 功能是让 Target 对象根据轨迹进行运动。脚本拖放在一个对象上之后，然后，指定 Circuit 为刚才使用的WaypointCircuit。然后在指定 Target 对象。运行游戏就可以运动了。试试其他参数，来调节一下速度与运动方式。

    using System;
    using UnityEngine;
    
    namespace UnityStandardAssets.Utility
    {
        public class WaypointProgressTracker : MonoBehaviour
        {
            // This script can be used with any object that is supposed to follow a
            // route marked out by waypoints.
   
        // This script manages the amount to look ahead along the route,
        // and keeps track of progress and laps.
   
        [SerializeField] private WaypointCircuit circuit; // A reference to the waypoint-based route we should follow
   
        [SerializeField] private float lookAheadForTargetOffset = 5;
        // The offset ahead along the route that the we will aim for
   
        [SerializeField] private float lookAheadForTargetFactor = .1f;
        // A multiplier adding distance ahead along the route to aim for, based on current speed
   
        [SerializeField] private float lookAheadForSpeedOffset = 10;
        // The offset ahead only the route for speed adjustments (applied as the rotation of the waypoint target transform)
   
        [SerializeField] private float lookAheadForSpeedFactor = .2f;
        // A multiplier adding distance ahead along the route for speed adjustments
   
        [SerializeField] private ProgressStyle progressStyle = ProgressStyle.SmoothAlongRoute;
        // whether to update the position smoothly along the route (good for curved paths) or just when we reach each waypoint.
   
        [SerializeField] private float pointToPointThreshold = 4;
        // proximity to waypoint which must be reached to switch target to next waypoint : only used in PointToPoint mode.
   
        public enum ProgressStyle
        {
            SmoothAlongRoute,
            PointToPoint,
        }
   
        // these are public, readable by other objects - i.e. for an AI to know where to head!
        public WaypointCircuit.RoutePoint targetPoint { get; private set; }
        public WaypointCircuit.RoutePoint speedPoint { get; private set; }
        public WaypointCircuit.RoutePoint progressPoint { get; private set; }
   
        public Transform target;
   
        private float progressDistance; // The progress round the route, used in smooth mode.
        private int progressNum; // the current waypoint number, used in point-to-point mode.
        private Vector3 lastPosition; // Used to calculate current speed (since we may not have a rigidbody component)
        private float speed; // current speed of this object (calculated from delta since last frame)
   
        // setup script properties
        private void Start()
        {
            // we use a transform to represent the point to aim for, and the point which
            // is considered for upcoming changes-of-speed. This allows this component
            // to communicate this information to the AI without requiring further dependencies.
   
            // You can manually create a transform and assign it to this component *and* the AI,
            // then this component will update it, and the AI can read it.
            if (target == null)
            {
                target = new GameObject(name + " Waypoint Target").transform;
            }
   
            Reset();
        }
   
   
        // reset the object to sensible values
        public void Reset()
        {
            progressDistance = 0;
            progressNum = 0;
            if (progressStyle == ProgressStyle.PointToPoint)
            {
                target.position = circuit.Waypoints[progressNum].position;
                target.rotation = circuit.Waypoints[progressNum].rotation;
            }
        }
   
   
        private void Update()
        {
            if (progressStyle == ProgressStyle.SmoothAlongRoute)
            {
                // determine the position we should currently be aiming for
                // (this is different to the current progress position, it is a a certain amount ahead along the route)
                // we use lerp as a simple way of smoothing out the speed over time.
                if (Time.deltaTime > 0)
                {
                    speed = Mathf.Lerp(speed, (lastPosition - transform.position).magnitude/Time.deltaTime,
                                       Time.deltaTime);
                }
                target.position =
                    circuit.GetRoutePoint(progressDistance + lookAheadForTargetOffset + lookAheadForTargetFactor*speed)
                           .position;
                target.rotation =
                    Quaternion.LookRotation(
                        circuit.GetRoutePoint(progressDistance + lookAheadForSpeedOffset + lookAheadForSpeedFactor*speed)
                               .direction);
   
   
                // get our current progress along the route
                progressPoint = circuit.GetRoutePoint(progressDistance);
                Vector3 progressDelta = progressPoint.position - transform.position;
                if (Vector3.Dot(progressDelta, progressPoint.direction) < 0)
                {
                    progressDistance += progressDelta.magnitude*0.5f;
                }
   
                lastPosition = transform.position;
            }
            else
            {
                // point to point mode. Just increase the waypoint if we're close enough:
   
                Vector3 targetDelta = target.position - transform.position;
                if (targetDelta.magnitude < pointToPointThreshold)
                {
                    progressNum = (progressNum + 1)%circuit.Waypoints.Length;
                }
   
   
                target.position = circuit.Waypoints[progressNum].position;
                target.rotation = circuit.Waypoints[progressNum].rotation;
   
                // get our current progress along the route
                progressPoint = circuit.GetRoutePoint(progressDistance);
                Vector3 progressDelta = progressPoint.position - transform.position;
                if (Vector3.Dot(progressDelta, progressPoint.direction) < 0)
                {
                    progressDistance += progressDelta.magnitude;
                }
                lastPosition = transform.position;
            }
        }
   
   
        private void OnDrawGizmos()
        {
            if (Application.isPlaying)
            {
                Gizmos.color = Color.green;
                Gizmos.DrawLine(transform.position, target.position);
                Gizmos.DrawWireSphere(circuit.GetRoutePosition(progressDistance), 1);
                Gizmos.color = Color.yellow;
                Gizmos.DrawLine(target.position, target.position + target.forward);
            }
        }
    }
    }
   
   

---

Hello ,I am Edwin

---

首先谢谢大家的支持，其次如果你碰到什么其他问题的话，欢迎来 我自己的一个 讨论群559666429来(扫扫下面二维码),大家一起找答案，共同进步。 同时欢迎各大需求商入住，发布自己的需求，给群内伙伴提供副职，赚取外快。

---