Initial project commit

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/AnimateCarAlongSplineEditor.cs

@@ -0,0 +1,15 @@
+using Unity.Splines.Examples;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Splines.Examples
+{
+    [CustomEditor(typeof(AnimateCarAlongSpline))]
+    public class AnimateCarAlongSplineEditor : UnityEditor.Editor
+    {
+        void OnEnable()
+        {
+            ((AnimateCarAlongSpline)target).Initialize();
+        }
+    }
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/AnimateCarAlongSplineEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b2f7adbf743913a4ea009f06573bd6bb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/LoftRoadEditor.cs

@@ -0,0 +1,25 @@
+using UnityEditor;
+
+namespace Unity.Splines.Examples.Editor
+{
+    [CustomEditor(typeof(LoftRoadBehaviour))]
+    [CanEditMultipleObjects]
+    class SplineWidthEditor : UnityEditor.Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            base.OnInspectorGUI();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                EditorApplication.delayCall += () =>
+                {
+                    foreach (var target in targets)
+                        ((LoftRoadBehaviour)target).LoftAllRoads();
+                };
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/LoftRoadEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b853bdae9b934578bcdc53c189a69514
+timeCreated: 1617911316

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/PackageDependencyChecker.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.PackageManager.Requests;
+using UnityEditor.PackageManager;
+using UnityEngine;
+
+namespace Unity.Splines.Examples.Editor
+{
+    static class PackageDependencyChecker
+    {
+        const string k_SessionStateCheck = "SplinePackageExampleDependencyCheckPerformed";
+        static ListRequest s_Request;
+        static readonly List<string> s_PackageIDs = new()
+        {
+            "com.unity.render-pipelines.high-definition",
+            "com.unity.render-pipelines.universal",
+            "com.unity.shadergraph"
+        };
+
+        [InitializeOnLoadMethod]
+        static void CheckDependencies()
+        {
+            if (SessionState.GetBool(k_SessionStateCheck, false))
+                return;
+            SessionState.SetBool(k_SessionStateCheck, true);
+            s_Request = Client.List();
+            EditorApplication.update += PollRequest;
+        }
+
+        static void PollRequest()
+        {
+            if (s_Request.IsCompleted)
+            {
+                var found = false;
+                if (s_Request.Status == StatusCode.Success)
+                {
+                    foreach (var package in s_Request.Result)
+                    {
+                        if (s_PackageIDs.Contains(package.name))
+                        {
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+
+                if (!found)
+                    Debug.LogError("To properly view Splines Samples please install the Shader Graph package.");
+
+                EditorApplication.update -= PollRequest;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/PackageDependencyChecker.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 767e868410dee44af96ad2c5650f86f1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d201921c91066614f860be50a2824614
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/DriftTool.cs

@@ -0,0 +1,163 @@
+using System.Collections;
+using System.Collections.Generic;
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEditor.EditorTools;
+using UnityEditor.Splines;
+using UnityEngine;
+using UnityEngine.Splines;
+
+using Interpolators = UnityEngine.Splines.Interpolators;
+
+namespace Unity.Splines.Examples
+{
+    [EditorTool("Drift Tool", typeof(DriftSplineData))]
+    public class DriftTool : SplineDataToolBase<float>, IDrawSelectedHandles
+    {
+        float m_DisplaySpace = 0.2f;
+        List<Vector3> m_LineSegments = new List<Vector3>();
+
+        GUIContent m_IconContent;
+        public override GUIContent toolbarIcon => m_IconContent;
+
+        bool m_DriftInUse;
+
+        void OnEnable()
+        {
+            m_IconContent = new GUIContent()
+            {
+                image = Resources.Load<Texture2D>("Icons/DriftTool"),
+                text = "Drift Tool",
+                tooltip = "Adjust how much the vehicle is drifting away from the spline."
+            };
+        }
+
+        public override void OnToolGUI(EditorWindow window)
+        {
+            var splineDataTarget = target as DriftSplineData;
+
+            if (splineDataTarget == null || splineDataTarget.Container == null)
+                return;
+
+            Undo.RecordObject(splineDataTarget, "Modifying Drift SplineData");
+            var nativeSpline = new NativeSpline(splineDataTarget.Container.Spline, splineDataTarget.Container.transform.localToWorldMatrix);
+
+            Handles.color = Color.green;
+
+            //User defined : Handles to manipulate Drift data
+            m_DriftInUse = DrawDataPoints(nativeSpline, splineDataTarget.Drift);
+            //Use defined : Draws a line along the whole Drift SplineData
+            DrawSplineData(nativeSpline, splineDataTarget.Drift);
+
+            //Using the out-of the box behaviour to manipulate SplineData indexes
+            nativeSpline.DataPointHandles(splineDataTarget.Drift);
+        }
+
+        public void OnDrawHandles()
+        {
+            var splineDataTarget = target as DriftSplineData;
+            if (ToolManager.IsActiveTool(this) || splineDataTarget.Container == null)
+                return;
+
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            var nativeSpline = new NativeSpline(splineDataTarget.Container.Spline, splineDataTarget.Container.transform.localToWorldMatrix);
+
+            Color color = Color.green;
+            color.a = 0.5f;
+            Handles.color = color;
+            DrawSplineData(nativeSpline, splineDataTarget.Drift);
+        }
+
+        protected override bool DrawDataPoint(
+            Vector3 position,
+            Vector3 tangent,
+            Vector3 up,
+            float inValue,
+            out float outValue)
+        {
+            outValue = 0f;
+            if (tangent == Vector3.zero)
+                return false;
+
+            var controlID = GUIUtility.GetControlID(FocusType.Passive);
+
+            var handleColor = Handles.color;
+            if (GUIUtility.hotControl == controlID)
+                handleColor = Handles.selectedColor;
+            else if (GUIUtility.hotControl == 0 && HandleUtility.nearestControl == controlID)
+                handleColor = Handles.preselectionColor;
+
+            var right = math.normalize(math.cross(up, tangent));
+            var extremity = position + inValue * (Vector3)right;
+
+            using (new Handles.DrawingScope(handleColor))
+            {
+                var size = 1.5f * k_HandleSize * HandleUtility.GetHandleSize(position);
+                Handles.DrawLine(position, extremity);
+                var val = Handles.Slider(
+                    controlID,
+                    extremity,
+                    inValue == 0 ? right : right * math.sign(inValue),
+                    size,
+                    Handles.ConeHandleCap,
+                    0);
+                Handles.Label(extremity + 2f * size * Vector3.up, inValue.ToString());
+
+                if (GUIUtility.hotControl == controlID)
+                {
+                    outValue = (val - position).magnitude * math.sign(math.dot(val - position, right));
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        void DrawSplineData(NativeSpline spline, SplineData<float> splineData)
+        {
+            m_LineSegments.Clear();
+            if (GUIUtility.hotControl == 0
+                || m_DriftInUse
+                || !ToolManager.IsActiveTool(this)
+                || Tools.viewToolActive)
+            {
+                var data = splineData.Evaluate(spline, 0, PathIndexUnit.Distance, new Interpolators.LerpFloat());
+                spline.Evaluate(0, out var position, out var direction, out var upDirection);
+
+                var right = math.normalize(math.cross(upDirection, direction));
+                var previousExtremity = (Vector3)position + data * (Vector3)right;
+
+                var currentOffset = m_DisplaySpace;
+                while (currentOffset < spline.GetLength())
+                {
+                    var t = currentOffset / spline.GetLength();
+                    spline.Evaluate(t, out position, out direction, out upDirection);
+
+                    right = math.normalize(math.cross(upDirection, direction));
+
+                    data = splineData.Evaluate(spline, currentOffset, PathIndexUnit.Distance, new Interpolators.LerpFloat());
+
+                    var extremity = (Vector3)position + data * (Vector3)right;
+
+                    m_LineSegments.Add(previousExtremity);
+                    m_LineSegments.Add(extremity);
+
+                    currentOffset += m_DisplaySpace;
+                    previousExtremity = extremity;
+                }
+
+                spline.Evaluate(1, out position, out direction, out upDirection);
+
+                right = math.normalize(math.cross(upDirection, direction));
+                data = splineData.Evaluate(spline, 1f, PathIndexUnit.Normalized, new Interpolators.LerpFloat());
+
+                var lastExtremity = (Vector3)position + data * (Vector3)right;
+
+                m_LineSegments.Add(previousExtremity);
+                m_LineSegments.Add(lastExtremity);
+            }
+            Handles.DrawLines(m_LineSegments.ToArray());
+        }
+    }
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/DriftTool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a02b7ee8b850af34e906a2a59186f9ae
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/SpeedTiltDropdown.cs

@@ -0,0 +1,48 @@
+using System;
+using UnityEditor;
+using UnityEditor.Toolbars;
+using UnityEngine;
+
+namespace Unity.Splines.Examples
+{
+    [EditorToolbarElement("SpeedTiltTool/SplineDataType")]
+    public class SpeedTiltDropdown : EditorToolbarDropdown
+    {
+        string[] m_SplineDataTypes = new[]
+        {
+            SpeedTiltTool.SplineDataType.SpeedData.ToString(),
+                 SpeedTiltTool.SplineDataType.TiltData.ToString()
+        };
+
+        [Obsolete("Use Tooltip instead.", false)]
+        public string k_Tooltip = "Select the SplineData to target for interactions.";
+        public string Tooltip = "Select the SplineData to target for interactions.";
+
+        public SpeedTiltDropdown()
+        {
+            name = "SplineData Target Type";
+
+            clicked += OpenContextMenu;
+            text = m_SplineDataTypes[(int)SpeedTiltTool.selectedSplineData];
+        }
+
+        void OpenContextMenu()
+        {
+            var menu = new GenericMenu();
+            for (int i = 0; i < m_SplineDataTypes.Length; i++)
+            {
+                var index = i;
+                var component = m_SplineDataTypes[i];
+                menu.AddItem(new GUIContent(component, Tooltip), text == component,
+                    () => SetSelectedComponent(index));
+            }
+            menu.DropDown(worldBound);
+        }
+
+        void SetSelectedComponent(int selectedIndex)
+        {
+            text = m_SplineDataTypes[selectedIndex];
+            SpeedTiltTool.selectedSplineData = (SpeedTiltTool.SplineDataType)selectedIndex;
+        }
+    }
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/SpeedTiltDropdown.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d4c650b6f99c0d149be6ca04cbb10e7e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/SpeedTiltTool.cs

@@ -0,0 +1,409 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEditor.EditorTools;
+using UnityEditor.Splines;
+using UnityEngine;
+using UnityEngine.Splines;
+#if UNITY_2022_1_OR_NEWER
+using UnityEditor.Overlays;
+#else
+using System.Reflection;
+using UnityEditor.Toolbars;
+using UnityEngine.UIElements;
+#endif
+
+using Interpolators = UnityEngine.Splines.Interpolators;
+
+namespace Unity.Splines.Examples
+{
+    [CustomEditor(typeof(SpeedTiltTool))]
+#if UNITY_2022_1_OR_NEWER
+    class SplineDataPointToolSettings : UnityEditor.Editor, ICreateToolbar
+#else
+    class SplineDataPointToolSettings : UnityEditor.Editor
+#endif
+    {
+        public virtual IEnumerable<string> toolbarElements
+        {
+            get
+            {
+                yield return "Tool Settings/Pivot Mode";
+                yield return "Tool Settings/Pivot Rotation";
+                yield return "SpeedTiltTool/SplineDataType";
+            }
+        }
+
+#if !UNITY_2022_1_OR_NEWER
+        const string k_ElementClassName = "unity-editor-toolbar-element";
+        const string k_StyleSheetsPath = "StyleSheets/Toolbars/";
+
+        static VisualElement CreateToolbar()
+        {
+            var target = new VisualElement();
+            var path = k_StyleSheetsPath + "EditorToolbar";
+
+            var common = EditorGUIUtility.Load($"{path}Common.uss") as StyleSheet;
+            if (common != null)
+                target.styleSheets.Add(common);
+
+            var themeSpecificName = EditorGUIUtility.isProSkin ? "Dark" : "Light";
+            var themeSpecific = EditorGUIUtility.Load($"{path}{themeSpecificName}.uss") as StyleSheet;
+            if (themeSpecific != null)
+                target.styleSheets.Add(themeSpecific);
+
+            target.AddToClassList("unity-toolbar-overlay");
+            target.style.flexDirection = FlexDirection.Row;
+            return target;
+        }
+
+        public override VisualElement CreateInspectorGUI()
+        {
+            var root = CreateToolbar();
+
+            var elements = TypeCache.GetTypesWithAttribute(typeof(EditorToolbarElementAttribute));
+
+            foreach (var element in toolbarElements)
+            {
+                var type = elements.FirstOrDefault(x =>
+                {
+                    var attrib = x.GetCustomAttribute<EditorToolbarElementAttribute>();
+                    return attrib != null && attrib.id == element;
+                });
+
+                if (type != null)
+                {
+                    try
+                    {
+                        const BindingFlags flags =  BindingFlags.Instance |
+                            BindingFlags.Public |
+                            BindingFlags.NonPublic |
+                            BindingFlags.CreateInstance;
+
+                        var ve = (VisualElement)Activator.CreateInstance(type, flags, null, null, null, null);
+                        ve.AddToClassList(k_ElementClassName);
+                        root.Add(ve);
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogError($"Failed creating toolbar element from ID \"{element}\".\n{e}");
+                    }
+                }
+            }
+
+            EditorToolbarUtility.SetupChildrenAsButtonStrip(root);
+
+            return root;
+        }
+
+#endif
+    }
+
+    [EditorTool("Speed & Tilt Tool", typeof(AnimateCarAlongSpline))]
+    public class SpeedTiltTool : EditorTool, IDrawSelectedHandles
+    {
+        internal enum SplineDataType
+        {
+            SpeedData,
+            TiltData
+        };
+
+        //Speed handles parameters
+        const float k_SpeedScaleFactor = 10f;
+        const float k_DisplaySpace = 0.5f;
+
+        //Tilt handles parameters
+        Quaternion m_StartingRotation;
+
+        const float k_HandleSize = 0.15f;
+
+        Color[] m_HandlesColors = {Color.red, new(1f, 0.6f, 0f)};
+        List<Vector3> m_LineSegments = new List<Vector3>();
+        static SplineDataType s_SelectedSplineData = SplineDataType.SpeedData;
+        internal static SplineDataType selectedSplineData
+        {
+            get => s_SelectedSplineData;
+            set => s_SelectedSplineData = value;
+        }
+
+        GUIContent m_IconContent;
+        public override GUIContent toolbarIcon => m_IconContent;
+
+        bool m_DisableHandles;
+        bool m_SpeedInUse;
+        bool m_TiltInUse;
+
+        void OnEnable()
+        {
+            m_IconContent = new GUIContent()
+            {
+                image = Resources.Load<Texture2D>("Icons/SpeedTiltTool"),
+                text = "Speed & Tilt Tool",
+                tooltip = "Adjust the vehicle speed and tilt DataPoints along the spline."
+            };
+        }
+
+        public override void OnToolGUI(EditorWindow window)
+        {
+            var splineDataTarget = target as AnimateCarAlongSpline;
+            if (splineDataTarget == null || splineDataTarget.Container == null)
+                return;
+
+            var nativeSpline = new NativeSpline(splineDataTarget.Container.Spline, splineDataTarget.Container.transform.localToWorldMatrix);
+
+            Undo.RecordObject(splineDataTarget, "Modifying Speed and Tilt SplineData");
+
+            m_DisableHandles = false;
+
+            //Speed handles section
+            Handles.color = m_HandlesColors[(int)SplineDataType.SpeedData];
+            //User defined : Handles to manipulate Speed data
+            m_SpeedInUse = DrawSpeedDataPoints(nativeSpline, splineDataTarget.Speed, splineDataTarget.MaxSpeed, true);
+            //Use defined : Draws a line along the whole Speed SplineData
+            DrawSpeedSplineData(nativeSpline, splineDataTarget.Speed);
+
+            //Tilt handles section
+            Handles.color = m_HandlesColors[(int)SplineDataType.TiltData];
+            //User defined : Handles to manipulate Tilt data
+            m_TiltInUse = DrawTiltDataPoints(nativeSpline, splineDataTarget.Tilt);
+            //Use defined : Draws a line along the whole Tilt SplineData
+            DrawTiltSplineData(nativeSpline, splineDataTarget.Tilt);
+
+            //Draw DataPoint default Manipulation handles
+            Handles.color = m_HandlesColors[(int)s_SelectedSplineData];
+            if (s_SelectedSplineData == SplineDataType.SpeedData)
+                nativeSpline.DataPointHandles(splineDataTarget.Speed);
+            else
+                nativeSpline.DataPointHandles(splineDataTarget.Tilt);
+        }
+
+        public void OnDrawHandles()
+        {
+            var splineDataTarget = target as AnimateCarAlongSpline;
+            if (ToolManager.IsActiveTool(this) || splineDataTarget.Container == null)
+                return;
+
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            m_DisableHandles = true;
+
+            var nativeSpline = new NativeSpline(splineDataTarget.Container.Spline, splineDataTarget.Container.transform.localToWorldMatrix);
+            Color color = m_HandlesColors[(int)SplineDataType.SpeedData];
+            color.a = 0.5f;
+            Handles.color = color;
+            DrawSpeedDataPoints(nativeSpline, splineDataTarget.Speed, splineDataTarget.MaxSpeed, false);
+            DrawSpeedSplineData(nativeSpline, splineDataTarget.Speed);
+
+            color = m_HandlesColors[(int)SplineDataType.TiltData];
+            color.a = 0.5f;
+            Handles.color = color;
+            DrawTiltSplineData(nativeSpline, splineDataTarget.Tilt);
+        }
+
+        bool DrawSpeedDataPoints(NativeSpline spline, SplineData<float> speedSplineData, float maxSpeed, bool drawLabel)
+        {
+            var inUse = false;
+            for (int dataFrameIndex = 0; dataFrameIndex < speedSplineData.Count; dataFrameIndex++)
+            {
+                var dataPoint = speedSplineData[dataFrameIndex];
+
+                var normalizedT = SplineUtility.GetNormalizedInterpolation(spline, dataPoint.Index, speedSplineData.PathIndexUnit);
+                var position = spline.EvaluatePosition(normalizedT);
+
+                var speedValue = dataPoint.Value;
+                if (speedValue > maxSpeed)
+                {
+                    speedValue = maxSpeed;
+                    dataPoint.Value = maxSpeed;
+                    speedSplineData[dataFrameIndex] = dataPoint;
+                }
+
+                var id = m_DisableHandles ? -1 : GUIUtility.GetControlID(FocusType.Passive);
+                if (DrawSpeedDataPoint(id, position, speedValue, drawLabel, out var result))
+                {
+                    dataPoint.Value = Mathf.Clamp(result, 0.01f, maxSpeed);
+                    speedSplineData[dataFrameIndex] = dataPoint;
+                    inUse = true;
+                }
+            }
+
+            return inUse;
+        }
+
+        bool DrawSpeedDataPoint(
+            int controlID,
+            Vector3 position,
+            float inValue,
+            bool drawLabel,
+            out float outValue)
+        {
+            outValue = 0f;
+            var handleColor = Handles.color;
+            if (GUIUtility.hotControl == controlID)
+                handleColor = Handles.selectedColor;
+            else if (GUIUtility.hotControl == 0 && HandleUtility.nearestControl == controlID)
+                handleColor = Handles.preselectionColor;
+
+            var extremity = position + (inValue / k_SpeedScaleFactor) * Vector3.up;
+            using (new Handles.DrawingScope(handleColor))
+            {
+                var size = k_HandleSize * HandleUtility.GetHandleSize(position);
+                Handles.DrawLine(position, extremity);
+                var val = Handles.Slider(controlID, extremity, Vector3.up, size, Handles.SphereHandleCap, 0);
+                if (drawLabel)
+                    Handles.Label(extremity + 2f * size * Vector3.up, inValue.ToString());
+
+                if (GUIUtility.hotControl == controlID)
+                {
+                    outValue = k_SpeedScaleFactor * (val - position).magnitude * math.sign(math.dot(val - position, Vector3.up));
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        bool DrawTiltDataPoints(NativeSpline spline, SplineData<float3> tiltSplineData)
+        {
+            var inUse = false;
+            for (int dataFrameIndex = 0; dataFrameIndex < tiltSplineData.Count; dataFrameIndex++)
+            {
+                var dataPoint = tiltSplineData[dataFrameIndex];
+
+                var normalizedT = SplineUtility.GetNormalizedInterpolation(spline, dataPoint.Index, tiltSplineData.PathIndexUnit);
+                spline.Evaluate(normalizedT, out var position, out var tangent, out var up);
+
+                var id = m_DisableHandles ? -1 : GUIUtility.GetControlID(FocusType.Passive);
+                if (DrawTiltDataPoint(id, position, tangent, up, dataPoint.Value, out var result))
+                {
+                    dataPoint.Value = result;
+                    tiltSplineData[dataFrameIndex] = dataPoint;
+                    inUse = true;
+                }
+            }
+            return inUse;
+        }
+
+        bool DrawTiltDataPoint(
+            int controlID,
+            Vector3 position,
+            Vector3 tangent,
+            Vector3 up,
+            float3 inValue,
+            out float3 outValue)
+        {
+            outValue = float3.zero;
+            if (tangent == Vector3.zero)
+                return false;
+
+            Matrix4x4 localMatrix = Matrix4x4.identity;
+            localMatrix.SetTRS(position, Quaternion.LookRotation(tangent, up), Vector3.one);
+
+            var matrix = Handles.matrix * localMatrix;
+            using (new Handles.DrawingScope(matrix))
+            {
+                var dataPointRotation = Quaternion.FromToRotation(Vector3.up, inValue);
+
+                if (GUIUtility.hotControl == 0)
+                    m_StartingRotation = dataPointRotation;
+
+                var color = Handles.color;
+                if (!m_TiltInUse)
+                    color.a = 0.33f;
+
+                if (Event.current.type == EventType.Repaint)
+                {
+                    using (new Handles.DrawingScope(color))
+                        Handles.ArrowHandleCap(-1, Vector3.zero, Quaternion.FromToRotation(Vector3.forward, inValue), 1f, EventType.Repaint);
+                }
+
+                var rotation = Handles.Disc(controlID, dataPointRotation, Vector3.zero, Vector3.forward, 1, false, 0);
+
+                if (GUIUtility.hotControl == controlID)
+                {
+                    var deltaRot = Quaternion.Inverse(m_StartingRotation) * rotation;
+                    outValue = deltaRot * m_StartingRotation * Vector3.up;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        void DrawSpeedSplineData(NativeSpline spline, SplineData<float> splineData)
+        {
+            m_LineSegments.Clear();
+            if (GUIUtility.hotControl == 0
+                || m_SpeedInUse
+                || !ToolManager.IsActiveTool(this)
+                || Tools.viewToolActive)
+            {
+                var data = splineData.Evaluate(spline, 0, PathIndexUnit.Distance, new Interpolators.LerpFloat());
+                var position = spline.EvaluatePosition(0);
+                var previousExtremity = (Vector3)position + (data / k_SpeedScaleFactor) * Vector3.up;
+
+                var currentOffset = k_DisplaySpace;
+                while (currentOffset < spline.GetLength())
+                {
+                    var t = currentOffset / spline.GetLength();
+                    position = spline.EvaluatePosition(t);
+                    data = splineData.Evaluate(spline, currentOffset, PathIndexUnit.Distance, new Interpolators.LerpFloat());
+
+                    var extremity = (Vector3)position + (data / k_SpeedScaleFactor) * Vector3.up;
+
+                    m_LineSegments.Add(previousExtremity);
+                    m_LineSegments.Add(extremity);
+
+                    currentOffset += k_DisplaySpace;
+                    previousExtremity = extremity;
+                }
+
+                position = spline.EvaluatePosition(1);
+                data = splineData.Evaluate(spline, spline.GetLength(), PathIndexUnit.Distance, new Interpolators.LerpFloat());
+
+                var lastExtremity = (Vector3)position + (data / k_SpeedScaleFactor) * Vector3.up;
+
+                m_LineSegments.Add(previousExtremity);
+                m_LineSegments.Add(lastExtremity);
+            }
+            Handles.DrawLines(m_LineSegments.ToArray());
+        }
+
+        void DrawTiltSplineData(NativeSpline spline, SplineData<float3> splineData)
+        {
+            m_LineSegments.Clear();
+            if (GUIUtility.hotControl == 0
+                || m_TiltInUse
+                || !ToolManager.IsActiveTool(this)
+                || Tools.viewToolActive)
+            {
+                var currentOffset = k_DisplaySpace;
+                while (currentOffset < spline.GetLength())
+                {
+                    var t = currentOffset / spline.GetLength();
+                    spline.Evaluate(t, out float3 position, out float3 direction, out float3 up);
+                    var data = splineData.Evaluate(spline, t, PathIndexUnit.Normalized,
+                        new Interpolators.LerpFloat3());
+
+                    Matrix4x4 localMatrix = Matrix4x4.identity;
+                    localMatrix.SetTRS(position, Quaternion.LookRotation(direction, up), Vector3.one);
+                    m_LineSegments.Add(localMatrix.GetPosition());
+                    m_LineSegments.Add(localMatrix.MultiplyPoint(math.normalize(data)));
+
+                    currentOffset += k_DisplaySpace;
+                }
+            }
+
+            var color = Handles.color;
+            if (!m_TiltInUse)
+                color.a = 0.33f;
+
+            using (new Handles.DrawingScope(color))
+                Handles.DrawLines(m_LineSegments.ToArray());
+        }
+    }
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/SpeedTiltTool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 13191b70b1bbf4348a215f42c3e852cf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/SplineDataToolBase.cs

@@ -0,0 +1,47 @@
+using UnityEditor.EditorTools;
+using UnityEngine;
+using UnityEngine.Splines;
+
+namespace Unity.Splines.Examples
+{
+    public abstract class SplineDataToolBase<DataType> : EditorTool
+    {
+        protected const float k_HandleSize = 0.15f;
+
+        protected bool DrawDataPoints(ISpline spline, SplineData<DataType> splineData)
+        {
+            var inUse = false;
+            for (int dataFrameIndex = 0; dataFrameIndex < splineData.Count; dataFrameIndex++)
+            {
+                var dataPoint = splineData[dataFrameIndex];
+
+                var normalizedT = SplineUtility.GetNormalizedInterpolation(spline, dataPoint.Index, splineData.PathIndexUnit);
+                spline.Evaluate(normalizedT, out var position, out var tangent, out var up);
+
+                if (DrawDataPoint(position, tangent, up, dataPoint.Value, out var result))
+                {
+                    dataPoint.Value = result;
+                    splineData[dataFrameIndex] = dataPoint;
+                    inUse = true;
+                }
+            }
+            return inUse;
+        }
+
+        /// <summary>
+        /// User defined method, for simplicity here, all the SplineData Tools have to override the same DrawDataPoint method for consistency between tools
+        /// </summary>
+        /// <param name="position"></param>
+        /// <param name="tangent"></param>
+        /// <param name="up"></param>
+        /// <param name="inValue"></param>
+        /// <param name="outValue"></param>
+        /// <returns>True if the dataPoint is manipulated, else false.</returns>
+        protected abstract bool DrawDataPoint(
+            Vector3 position,
+            Vector3 tangent,
+            Vector3 up,
+            DataType inValue,
+            out DataType outValue);
+    }
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/SplineDataToolBase.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: af7617c1ec3b5f94fb17427d7465e15b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/WidthTool.cs

@@ -0,0 +1,147 @@
+using Unity.Mathematics;
+using UnityEditor;
+using UnityEditor.EditorTools;
+using UnityEditor.Splines;
+using UnityEngine;
+using UnityEngine.Splines;
+
+namespace Unity.Splines.Examples
+{
+    [EditorTool("Width Tool", typeof(LoftRoadBehaviour))]
+    public class WidthTool : SplineDataToolBase<float>, IDrawSelectedHandles
+    {
+        GUIContent m_IconContent;
+        public override GUIContent toolbarIcon => m_IconContent;
+
+        bool m_DisableHandles = false;
+
+        void OnEnable()
+        {
+            m_IconContent = new GUIContent()
+            {
+                image = Resources.Load<Texture2D>("Icons/WidthTool"),
+                text = "Width Tool",
+                tooltip = "Adjust the width of the created road mesh."
+            };
+        }
+
+        public override void OnToolGUI(EditorWindow window)
+        {
+            var splineDataTarget = target as LoftRoadBehaviour;
+            if (splineDataTarget == null || splineDataTarget.Container == null)
+                return;
+
+            Handles.color = Color.blue;
+            m_DisableHandles = false;
+
+            var splines = splineDataTarget.Container.Splines;
+            for (var i = 0; i < splines.Count; i++)
+            {
+                if (i < splineDataTarget.Widths.Count)
+                {
+                    var nativeSpline = new NativeSpline(splines[i], splineDataTarget.Container.transform.localToWorldMatrix);
+
+                    Undo.RecordObject(splineDataTarget, "Modifying Widths SplineData");
+
+                    // User defined handles to manipulate width
+                    DrawDataPoints(nativeSpline, splineDataTarget.Widths[i]);
+
+                    // Using the out-of the box behaviour to manipulate indexes
+                    nativeSpline.DataPointHandles(splineDataTarget.Widths[i], false, i);
+                }
+            }
+        }
+
+        public void OnDrawHandles()
+        {
+            var splineDataTarget = target as LoftRoadBehaviour;
+            if (ToolManager.IsActiveTool(this) || splineDataTarget.Container == null)
+                return;
+
+            Color color = Color.blue;
+            color.a = 0.5f;
+            Handles.color = color;
+            m_DisableHandles = true;
+
+            var splines = splineDataTarget.Container.Splines;
+            for (var i = 0; i < splines.Count; i++)
+            {
+                if (i < splineDataTarget.Widths.Count)
+                {
+                    var nativeSpline = new NativeSpline(splines[i], splineDataTarget.Container.transform.localToWorldMatrix);
+                    DrawDataPoints(nativeSpline, splineDataTarget.Widths[i]);
+                }
+            }
+        }
+
+        protected override bool DrawDataPoint(
+            Vector3 position,
+            Vector3 tangent,
+            Vector3 up,
+            float inValue,
+            out float outValue)
+        {
+            int id1 = m_DisableHandles ? -1 : GUIUtility.GetControlID(FocusType.Passive);
+            int id2 = m_DisableHandles ? -1 : GUIUtility.GetControlID(FocusType.Passive);
+
+            outValue = 0f;
+            if (tangent == Vector3.zero)
+                return false;
+
+            if (Event.current.type == EventType.MouseUp
+                && Event.current.button != 0
+                && (GUIUtility.hotControl == id1 || GUIUtility.hotControl == id2))
+            {
+                Event.current.Use();
+                return false;
+            }
+
+            var handleColor = Handles.color;
+            if (GUIUtility.hotControl == id1 || GUIUtility.hotControl == id2)
+                handleColor = Handles.selectedColor;
+            else if (GUIUtility.hotControl == 0 && (HandleUtility.nearestControl == id1 || HandleUtility.nearestControl == id2))
+                handleColor = Handles.preselectionColor;
+
+            var normalDirection = math.normalize(math.cross(tangent, up));
+
+            var extremity1 = position - inValue * (Vector3)normalDirection;
+            var extremity2 = position + inValue * (Vector3)normalDirection;
+            Vector3 val1, val2;
+            using (new Handles.DrawingScope(handleColor))
+            {
+                if (Event.current.type == EventType.Repaint)
+                    Handles.DrawLine(extremity1, extremity2);
+
+                val1 = Handles.Slider(id1, extremity1, normalDirection,
+                    k_HandleSize * .5f * HandleUtility.GetHandleSize(position), CustomHandleCap, 0);
+                val2 = Handles.Slider(id2, extremity2, normalDirection,
+                    k_HandleSize * .5f * HandleUtility.GetHandleSize(position), CustomHandleCap, 0);
+            }
+
+            if (GUIUtility.hotControl == id1 && math.abs((val1 - extremity1).magnitude) > 0)
+            {
+                outValue = math.abs((val1 - position).magnitude);
+                return true;
+            }
+
+            if (GUIUtility.hotControl == id2 && math.abs((val2 - extremity2).magnitude) > 0)
+            {
+                outValue = math.abs((val2 - position).magnitude);
+                return true;
+            }
+
+            return false;
+        }
+
+        public void CustomHandleCap(int controlID, Vector3 position, Quaternion rotation, float size, EventType eventType)
+        {
+            if (m_DisableHandles) // If disabled, do nothing unless it's a repaint event
+            {
+                if (Event.current.type == EventType.Repaint)
+                    Handles.CubeHandleCap(controlID, position, rotation, size, eventType);
+            }
+            else
+                Handles.CubeHandleCap(controlID, position, rotation, size, eventType);
+        }
+    }
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Tools/WidthTool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 161dbe244d397fa478a292687ea673e9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Unity.Splines.Examples.Editor.asmdef

@@ -0,0 +1,21 @@
+{
+    "name": "Unity.Splines.Examples.Editor",
+    "rootNamespace": "",
+    "references": [
+        "GUID:21d1eb854b91ade49bc69a263d12bee2",
+        "GUID:e43142fc3fec6554980dde6126631f1d",
+        "GUID:d8b63aba1907145bea998dd612889d6b",
+        "GUID:9f08613db0663446b876a5eae626aa45"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Library/PackageCache/com.unity.splines@1cb7d86fc7ff/Samples~/SplineExamples/Editor/Unity.Splines.Examples.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a404f125045a6d14eae7fba9d72bf4da
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: