- You can now store intermediate normal vectors along the spline. This vastly improves the accuracy of the normals. This doesn't affect the normals auto calculation performance because intermediate normals were calculated anyways, they just weren't stored

- Added option to view intermediate normal vectors in Scene view and not just the end points' normals. This helps visualize the normals along the spline. Note that, despite what the name suggests, this function doesn't require intermediate normals to be calculated, it simply uses BezierSpline's GetNormal function and renders those normals in Scene view

Author: yasirkula

.github/README.md

@@ -75,7 +75,7 @@ spline.Initialize( 2 );
 
 You can change the position, rotation, scale and normal values of the end points, as well as the positions of their control points to reshape the spline.
 
-End points have the following properties to store their transformational data: `position`, `localPosition`, `rotation`, `localRotation`, `eulerAngles`, `localEulerAngles`, `localScale`, `normal` and `autoCalculatedNormalAngleOffset`.
+End points have the following properties to store their transformational data: `position`, `localPosition`, `rotation`, `localRotation`, `eulerAngles`, `localEulerAngles`, `localScale`, `normal`, `autoCalculatedNormalAngleOffset` and `intermediateNormals`.
 
 Positions of control points can be tweaked using the following properties in BezierPoint: `precedingControlPointPosition`, `precedingControlPointLocalPosition`, `followingControlPointPosition` and `followingControlPointLocalPosition`. The local positions are relative to their corresponding end points.
 
@@ -110,9 +110,9 @@ If you want to create a linear path between the end points of the spline, you ca
 
 - **Auto calculate the normals**
 
-If you want to calculate the spline's normal vectors automatically, you can call the **AutoCalculateNormals( float normalAngle = 0f, int smoothness = 10 )** function (or, to call this function automatically when spline's end points are modified, simply change the spline's **autoCalculateNormals** and **autoCalculatedNormalsAngle** properties). All resulting normal vectors will be rotated around their Z axis by "normalAngle" degrees. Additionally, each end point's normal vector will be rotated by that end point's "autoCalculatedNormalAngleOffset" degrees. "smoothness" determines how many intermediate steps are taken between each consecutive end point to calculate those end points' normal vectors. More intermediate steps is better but also slower to calculate.
+If you want to calculate the spline's normal vectors automatically, you can call the **AutoCalculateNormals( float normalAngle = 0f, int smoothness = 10, bool calculateIntermediateNormals = false )** function (or, to call this function automatically when spline's end points are modified, simply change the spline's **autoCalculateNormals**, **autoCalculatedNormalsAngle** and **m_autoCalculatedIntermediateNormalsCount** properties). All resulting normal vectors will be rotated around their Z axis by "normalAngle" degrees. Additionally, each end point's normal vector will be rotated by that end point's "autoCalculatedNormalAngleOffset" degrees. "smoothness" determines how many intermediate steps are taken between each consecutive end point to calculate those end points' normal vectors. More intermediate steps is better but also slower to calculate. When "calculateIntermediateNormals" is enabled, calculated intermediate normals (determined by "smoothness") are cached at each end point. This results in smoother linear interpolation for normals. Otherwise, the intermediate normals aren't stored anywhere and only the end points' normals are used to estimate normals along the spline.
 
-If auto calculated normals don't look quite right despite modifying the "normalAngle" (*Auto Calculated Normals Angle* in the Inspector) and "autoCalculatedNormalAngleOffset" (*Normal Angle* in the Inspector) variables, you can either consider inserting new end points to the sections of the spline that normals don't behave correctly, or setting the normals manually.
+If auto calculated normals don't look quite right despite modifying the "calculateIntermediateNormals" (*Auto Calculated Intermediate Normals* in the Inspector), "normalAngle" (*Auto Calculated Normals Angle* in the Inspector) and "autoCalculatedNormalAngleOffset" (*Normal Angle* in the Inspector) variables, you can either consider inserting new end points to the sections of the spline that normals don't behave correctly, or setting the normals manually.
 
 - **Get notified when spline is modified**
 
@@ -136,7 +136,7 @@ Tangent is calculated using the first derivative of the spline formula and gives
 
 - `Vector3 GetNormal( float normalizedT )`
 
-Interpolates between the end points' normal vectors. Note that this plugin doesn't store any intermediate data between end point pairs, so if two consecutive end points have almost the opposite tangents, then their interpolated normal vector may not be correct at some parts of the spline. Inserting a new end point between these two end points could resolve this issue. By default, all normal vectors have value (0,1,0).
+Interpolates between the end points' normal vectors. If intermediate normals are calculated, they are interpolated to calculate the result. Otherwise, only the end points' normal vectors are interpolated and the resulting normal vectors may not be correct at some parts of the spline. Inserting new end point(s) to those sections of the spline could resolve this issue. By default, all normal vectors have value (0,1,0).
 
 - `BezierPoint.ExtraData GetExtraData( float normalizedT )`
 

Plugins/BezierSolution/BezierPoint.cs

@@ -3,6 +3,7 @@
 namespace BezierSolution
 {
 	[AddComponentMenu( "Bezier Solution/Bezier Point" )]
+	[HelpURL( "https://github.com/yasirkula/UnityBezierSolution" )]
 	public partial class BezierPoint : MonoBehaviour
 	{
 		public Vector3 localPosition
@@ -289,6 +290,23 @@ public float autoCalculatedNormalAngleOffset
 			}
 		}
 
+		[SerializeField, HideInInspector]
+		private Vector3[] m_intermediateNormals;
+		public Vector3[] intermediateNormals
+		{
+			get { return m_intermediateNormals; }
+			set
+			{
+				// In this special case, don't early exit if the assigned array is the same because one of its elements might have changed.
+				// We can safely early exit if the assigned value was null or empty, though
+				if( ( m_intermediateNormals == null || m_intermediateNormals.Length == 0 ) && ( value == null || value.Length == 0 ) )
+					return;
+
+				m_intermediateNormals = value;
+				spline.dirtyFlags |= InternalDirtyFlags.NormalChange;
+			}
+		}
+
 		[SerializeField, HideInInspector]
 		[UnityEngine.Serialization.FormerlySerializedAs( "extraData" )]
 		private ExtraData m_extraData;
@@ -387,6 +405,31 @@ internal void RefreshIfChanged()
 			}
 		}
 
+		internal void SetNormalAndResetIntermediateNormals( Vector3 normal, string undo )
+		{
+			if( spline && spline.autoCalculateNormals )
+				return;
+
+#if UNITY_EDITOR
+			if( !string.IsNullOrEmpty( undo ) )
+				UnityEditor.Undo.RecordObject( this, undo );
+#endif
+
+			this.normal = normal;
+			intermediateNormals = null;
+
+			BezierPoint previousPoint = this.previousPoint;
+			if( previousPoint && previousPoint.m_intermediateNormals != null && previousPoint.m_intermediateNormals.Length > 0 )
+			{
+#if UNITY_EDITOR
+				if( !string.IsNullOrEmpty( undo ) )
+					UnityEditor.Undo.RecordObject( previousPoint, undo );
+#endif
+
+				previousPoint.intermediateNormals = null;
+			}
+		}
+
 		public void Reset()
 		{
 			localPosition = Vector3.zero;

Plugins/BezierSolution/BezierSpline.cs

@@ -11,6 +11,7 @@
 namespace BezierSolution
 {
 	[AddComponentMenu( "Bezier Solution/Bezier Spline" )]
+	[HelpURL( "https://github.com/yasirkula/UnityBezierSolution" )]
 	[ExecuteInEditMode]
 	public partial class BezierSpline : MonoBehaviour, IEnumerable<BezierPoint>
 	{
@@ -107,6 +108,23 @@ public float autoCalculatedNormalsAngle
 			}
 		}
 
+		[SerializeField, HideInInspector]
+		private int m_autoCalculatedIntermediateNormalsCount = 10;
+		public int autoCalculatedIntermediateNormalsCount
+		{
+			get { return m_autoCalculatedIntermediateNormalsCount; }
+			set
+			{
+				value = Mathf.Clamp( value, 0, 999 );
+
+				if( m_autoCalculatedIntermediateNormalsCount != value )
+				{
+					m_autoCalculatedIntermediateNormalsCount = value;
+					dirtyFlags |= InternalDirtyFlags.NormalOffsetChange;
+				}
+			}
+		}
+
 		private EvenlySpacedPointsHolder m_evenlySpacedPoints = null;
 		public EvenlySpacedPointsHolder evenlySpacedPoints
 		{
@@ -199,9 +217,12 @@ internal void CheckDirty()
 					}
 					else
 					{
-						AutoCalculateNormals( m_autoCalculatedNormalsAngle );
+						if( m_autoCalculatedIntermediateNormalsCount <= 0 )
+							AutoCalculateNormals( m_autoCalculatedNormalsAngle, calculateIntermediateNormals: false );
+						else
+							AutoCalculateNormals( m_autoCalculatedNormalsAngle, m_autoCalculatedIntermediateNormalsCount + 1, true );
 
-						// If an end point's normal vector was changed only, we've reverted that change by auto calculating the normals again
+						// If an end point's only normal vector was changed, we've reverted that change by auto calculating the normals again
 						dirtyFlags &= ~InternalDirtyFlags.NormalChange;
 
 						// If an end point's position or normal calculation offset was changed, then the spline's normals have indeed changed
@@ -636,11 +657,20 @@ public Vector3 GetNormal( float normalizedT )
 			if( endIndex == endPoints.Count )
 				endIndex = 0;
 
+			float localT = t - startIndex;
+
+			Vector3[] intermediateNormals = endPoints[startIndex].intermediateNormals;
+			if( intermediateNormals != null && intermediateNormals.Length > 0 )
+			{
+				localT *= intermediateNormals.Length - 1;
+				int localStartIndex = (int) localT;
+
+				return ( localStartIndex < intermediateNormals.Length - 1 ) ? Vector3.LerpUnclamped( intermediateNormals[localStartIndex], intermediateNormals[localStartIndex + 1], localT - localStartIndex ) : intermediateNormals[localStartIndex];
+			}
+
 			Vector3 startNormal = endPoints[startIndex].normal;
 			Vector3 endNormal = endPoints[endIndex].normal;
 
-			float localT = t - startIndex;
-
 			Vector3 normal = Vector3.LerpUnclamped( startNormal, endNormal, localT );
 			if( normal.y == 0f && normal.x == 0f && normal.z == 0f )
 			{
@@ -1091,14 +1121,18 @@ public void AutoConstructSpline2()
 
 		// Credit: https://stackoverflow.com/a/14241741/2373034
 		// Alternative approach: https://stackoverflow.com/a/25458216/2373034
-		public void AutoCalculateNormals( float normalAngle = 0f, int smoothness = 10 )
+		public void AutoCalculateNormals( float normalAngle = 0f, int smoothness = 10, bool calculateIntermediateNormals = false )
 		{
 			for( int i = 0; i < endPoints.Count; i++ )
 				endPoints[i].RefreshIfChanged();
 
+			Vector3 tangent = new Vector3(), rotatedNormal = new Vector3();
 			smoothness = Mathf.Max( 1, smoothness );
 			float _1OverSmoothness = 1f / smoothness;
 
+			if( smoothness <= 1 )
+				calculateIntermediateNormals = false;
+
 			// Calculate initial point's normal using Frenet formula
 			Segment segment = new Segment( endPoints[0], endPoints[1], 0f );
 			Vector3 tangent1 = segment.GetTangent( 0f ).normalized;
@@ -1107,7 +1141,9 @@ public void AutoCalculateNormals( float normalAngle = 0f, int smoothness = 10 )
 			if( Mathf.Approximately( cross.sqrMagnitude, 0f ) ) // This is not a curved spline but rather a straight line
 				cross = Vector3.Cross( tangent2, ( tangent2.x != 0f || tangent2.z != 0f ) ? Vector3.up : Vector3.forward );
 
-			endPoints[0].normal = Vector3.Cross( cross, tangent1 ).normalized;
+			// prevNormal stores the unrotated normal whereas endpoints[index].normal stores the rotated normal
+			Vector3 prevNormal = Vector3.Cross( cross, tangent1 ).normalized;
+			endPoints[0].normal = Quaternion.AngleAxis( normalAngle + endPoints[0].autoCalculatedNormalAngleOffset, tangent1 ) * prevNormal;
 
 			// Calculate other points' normals by iteratively (smoothness) calculating normals between the previous point and the next point
 			for( int i = 0; i < endPoints.Count; i++ )
@@ -1119,35 +1155,73 @@ public void AutoCalculateNormals( float normalAngle = 0f, int smoothness = 10 )
 				else
 					break;
 
-				Vector3 prevNormal = endPoints[i].normal;
+				Vector3[] intermediateNormals = null;
+				if( !calculateIntermediateNormals )
+					segment.point1.intermediateNormals = null;
+				else
+				{
+					intermediateNormals = segment.point1.intermediateNormals;
+					if( intermediateNormals == null || intermediateNormals.Length != smoothness + 1 )
+						segment.point1.intermediateNormals = intermediateNormals = new Vector3[smoothness + 1];
+
+					intermediateNormals[0] = segment.point1.normal;
+				}
+
+				float normalAngle1 = normalAngle + segment.point1.autoCalculatedNormalAngleOffset;
+				float normalAngle2 = normalAngle + segment.point2.autoCalculatedNormalAngleOffset;
+
 				for( int j = 1; j <= smoothness; j++ )
 				{
-					Vector3 tangent = segment.GetTangent( j * _1OverSmoothness ).normalized;
+					float localT = j * _1OverSmoothness;
+					tangent = segment.GetTangent( localT ).normalized;
 					prevNormal = Vector3.Cross( tangent, Vector3.Cross( prevNormal, tangent ).normalized ).normalized;
+
+					if( calculateIntermediateNormals )
+					{
+						float _normalAngle = Mathf.LerpUnclamped( normalAngle1, normalAngle2, localT );
+						intermediateNormals[j] = rotatedNormal = ( _normalAngle == 0f ) ? prevNormal : ( Quaternion.AngleAxis( _normalAngle, tangent ) * prevNormal );
+					}
 				}
 
-				if( i < endPoints.Count - 1 )
-					endPoints[i + 1].normal = prevNormal;
-				else if( prevNormal != -endPoints[0].normal )
-					endPoints[0].normal = ( endPoints[0].normal + prevNormal ).normalized;
-			}
+				if( !calculateIntermediateNormals )
+					rotatedNormal = ( normalAngle2 == 0f ) ? prevNormal : ( Quaternion.AngleAxis( normalAngle2, tangent ) * prevNormal );
 
-			// Rotate normals
-			for( int i = 0; i < endPoints.Count; i++ )
-			{
-				float rotateAngle = normalAngle + endPoints[i].autoCalculatedNormalAngleOffset;
-				if( Mathf.Approximately( rotateAngle, 180f ) )
-					endPoints[i].normal = -endPoints[i].normal;
-				else if( !Mathf.Approximately( rotateAngle, 0f ) )
+				if( i < endPoints.Count - 1 )
+					endPoints[i + 1].normal = rotatedNormal;
+				else
 				{
-					if( i < endPoints.Count - 1 )
-						segment = new Segment( endPoints[i], endPoints[i + 1], 0f );
-					else if( m_loop )
-						segment = new Segment( endPoints[i], endPoints[0], 0f );
+					if( !calculateIntermediateNormals )
+					{
+						if( rotatedNormal != -endPoints[0].normal )
+							endPoints[0].normal = ( endPoints[0].normal + rotatedNormal ).normalized;
+					}
 					else
-						segment = new Segment( endPoints[i - 1], endPoints[i], 1f );
-
-					endPoints[i].normal = Quaternion.AngleAxis( rotateAngle, segment.GetTangent() ) * endPoints[i].normal;
+					{
+						// In a looping spline, the first end point's normal value is a special case because the initial value that we've assigned to it
+						// might end up vastly different from the final rotatedNormal that we've found. To accommodate to this change, we'll find the
+						// angle difference between these two values and gradually apply that difference to the first end point's intermediate normals
+						Vector3 initialNormal0 = endPoints[0].normal;
+						float normal0DeltaAngle = Vector3.Angle( initialNormal0, rotatedNormal );
+						if( Mathf.Abs( normal0DeltaAngle ) > 5f )
+						{
+							// Vector3.SignedAngle: https://github.com/Unity-Technologies/UnityCsReference/blob/61f92bd79ae862c4465d35270f9d1d57befd1761/Runtime/Export/Math/Vector3.cs#L316-L328
+							// The function itself isn't available on Unity 5.6 so its source code is copy&pasted here
+							float cross_x = initialNormal0.y * rotatedNormal.z - initialNormal0.z * rotatedNormal.y;
+							float cross_y = initialNormal0.z * rotatedNormal.x - initialNormal0.x * rotatedNormal.z;
+							float cross_z = initialNormal0.x * rotatedNormal.y - initialNormal0.y * rotatedNormal.x;
+							normal0DeltaAngle *= Mathf.Sign( tangent.x * cross_x + tangent.y * cross_y + tangent.z * cross_z );
+
+							segment = new Segment( endPoints[0], endPoints[1], 0f );
+							intermediateNormals = endPoints[0].intermediateNormals;
+							endPoints[0].normal = intermediateNormals[0] = rotatedNormal;
+
+							for( int j = 1; j < smoothness; j++ )
+							{
+								float localT = j * _1OverSmoothness;
+								intermediateNormals[j] = Quaternion.AngleAxis( Mathf.LerpUnclamped( normal0DeltaAngle, 0f, localT ), segment.GetTangent( localT ).normalized ) * intermediateNormals[j];
+							}
+						}
+					}
 				}
 			}
 		}
@@ -1285,6 +1359,12 @@ public PointCache GeneratePointCache( EvenlySpacedPointsHolder lookupTable, Extr
 			return new PointCache( positions, normals, tangents, bitangents, extraDatas, loop );
 		}
 
+		public void ClearIntermediateNormals()
+		{
+			for( int i = 0; i < endPoints.Count; i++ )
+				endPoints[i].intermediateNormals = null;
+		}
+
 		private float AccuracyToStepSize( float accuracy )
 		{
 			if( accuracy <= 0f )

Plugins/BezierSolution/Editor/BezierPointEditor.cs

@@ -847,10 +847,7 @@ public override void OnInspectorGUI()
 			if( EditorGUI.EndChangeCheck() )
 			{
 				for( int i = 0; i < allPoints.Length; i++ )
-				{
-					Undo.RecordObject( allPoints[i], "Change Normal" );
-					allPoints[i].normal = normal;
-				}
+					allPoints[i].SetNormalAndResetIntermediateNormals( normal, "Change Normal" );
 
 				SceneView.RepaintAll();
 			}
@@ -860,10 +857,7 @@ public override void OnInspectorGUI()
 			{
 				Vector3 cameraPos = SceneView.lastActiveSceneView.camera.transform.position;
 				for( int i = 0; i < allPoints.Length; i++ )
-				{
-					Undo.RecordObject( allPoints[i], "Change Normal" );
-					allPoints[i].normal = ( cameraPos - allPoints[i].position ).normalized;
-				}
+					allPoints[i].SetNormalAndResetIntermediateNormals( ( cameraPos - allPoints[i].position ).normalized, "Change Normal" );
 
 				SceneView.RepaintAll();
 			}
@@ -916,8 +910,7 @@ public override void OnInspectorGUI()
 							else
 								tangent = new BezierSpline.Segment( spline[index - 1], spline[index], 1f ).GetTangent();
 
-							Undo.RecordObject( allPoints[i], "Change Normal Rotate Angle" );
-							allPoints[i].normal = Quaternion.AngleAxis( normalRotationAngle, tangent ) * allPoints[i].normal;
+							allPoints[i].SetNormalAndResetIntermediateNormals( Quaternion.AngleAxis( normalRotationAngle, tangent ) * allPoints[i].normal, "Change Normal Rotate Angle" );
 						}
 					}
 
@@ -1260,31 +1253,22 @@ internal static void CalculateInsertedPointPosition( BezierPoint neighbor1, Bezi
 		private void FlipNormals( IList<BezierPoint> points )
 		{
 			for( int i = 0; i < points.Count; i++ )
-			{
-				Undo.RecordObject( points[i], "Flip Normals" );
-				points[i].normal = -points[i].normal;
-			}
+				points[i].SetNormalAndResetIntermediateNormals( -points[i].normal, "Flip Normals" );
 		}
 
 		private void NormalizeNormals( IList<BezierPoint> points )
 		{
 			for( int i = 0; i < points.Count; i++ )
 			{
 				if( points[i].normal != Vector3.zero )
-				{
-					Undo.RecordObject( points[i], "Normalize Normals" );
-					points[i].normal = points[i].normal.normalized;
-				}
+					points[i].SetNormalAndResetIntermediateNormals( points[i].normal.normalized, "Normalize Normals" );
 			}
 		}
 
 		private void ResetNormals( IList<BezierPoint> points )
 		{
 			for( int i = 0; i < points.Count; i++ )
-			{
-				Undo.RecordObject( points[i], "Reset Normals" );
-				points[i].normal = Vector3.up;
-			}
+				points[i].SetNormalAndResetIntermediateNormals( Vector3.up, "Reset Normals" );
 		}
 
 		private void OnUndoRedo()