using UnityEngine;
using System;
using Cinemachine.Utility;
namespace Cinemachine
{
/// <summary>Defines a world-space path, consisting of an array of waypoints,
/// each of which has position, tangent, and roll settings. Bezier interpolation
/// is performed between the waypoints, to get a smooth and continuous path.</summary>
[DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
[AddComponentMenu("Cinemachine/CinemachinePath")]
[SaveDuringPlay]
[DisallowMultipleComponent]
[HelpURL(Documentation.BaseURL + "manual/CinemachinePath.html")]
public class CinemachinePath : CinemachinePathBase
{
/// <summary>A waypoint along the path</summary>
[DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
[Serializable] public struct Waypoint
{
/// <summary>Position in path-local space</summary>
[Tooltip("Position in path-local space")]
public Vector3 position;
/// <summary>Offset from the position, which defines the tangent of the curve at the waypoint.
/// The length of the tangent encodes the strength of the bezier handle.
/// The same handle is used symmetrically on both sides of the waypoint, to ensure smoothness.</summary>
[Tooltip("Offset from the position, which defines the tangent of the curve at the waypoint. "
+ "The length of the tangent encodes the strength of the bezier handle. The same handle "
+ "is used symmetrically on both sides of the waypoint, to ensure smoothness.")]
public Vector3 tangent;
/// <summary>Defines the roll of the path at this waypoint.
/// The other orientation axes are inferred from the tangent and world up.</summary>
[Tooltip("Defines the roll of the path at this waypoint. The other orientation axes are inferred from the tangent and world up.")]
public float roll;
}
/// <summary>If checked, then the path ends are joined to form a continuous loop</summary>
[Tooltip("If checked, then the path ends are joined to form a continuous loop.")]
public bool m_Looped;
/// <summary>The waypoints that define the path.
/// They will be interpolated using a bezier curve</summary>
[Tooltip("The waypoints that define the path. They will be interpolated using a bezier curve.")]
public Waypoint[] m_Waypoints = Array.Empty<Waypoint>();
/// <summary>The minimum value for the path position</summary>
public override float MinPos => 0;
/// <summary>The maximum value for the path position</summary>
public override float MaxPos
{
get
{
int count = m_Waypoints.Length - 1;
if (count < 1)
return 0;
return m_Looped ? count + 1 : count;
}
}
/// <summary>True if the path ends are joined to form a continuous loop</summary>
public override bool Looped => m_Looped;
private void Reset()
{
m_Looped = false;
m_Waypoints = new Waypoint[2]
{
new Waypoint { position = new Vector3(0, 0, -5), tangent = new Vector3(1, 0, 0) },
new Waypoint { position = new Vector3(0, 0, 5), tangent = new Vector3(1, 0, 0) }
};
m_Appearance = new Appearance();
InvalidateDistanceCache();
}
private void OnValidate() { InvalidateDistanceCache(); }
/// <summary>When calculating the distance cache, sample the path this many
/// times between points</summary>
public override int DistanceCacheSampleStepsPerSegment => m_Resolution;
/// <summary>Returns normalized position</summary>
float GetBoundingIndices(float pos, out int indexA, out int indexB)
{
pos = StandardizePos(pos);
int rounded = Mathf.RoundToInt(pos);
if (Mathf.Abs(pos - rounded) < UnityVectorExtensions.Epsilon)
indexA = indexB = (rounded == m_Waypoints.Length) ? 0 : rounded;
else
{
indexA = Mathf.FloorToInt(pos);
if (indexA >= m_Waypoints.Length)
{
pos -= MaxPos;
indexA = 0;
}
indexB = Mathf.CeilToInt(pos);
if (indexB >= m_Waypoints.Length)
indexB = 0;
}
return pos;
}
/// <summary>Get a worldspace position of a point along the path</summary>
/// <param name="pos">Postion along the path. Need not be normalized.</param>
/// <returns>Local-space position of the point along at path at pos</returns>
public override Vector3 EvaluateLocalPosition(float pos)
{
var result = Vector3.zero;
if (m_Waypoints.Length > 0)
{
pos = GetBoundingIndices(pos, out var indexA, out var indexB);
if (indexA == indexB)
result = m_Waypoints[indexA].position;
else
{
// interpolate
var wpA = m_Waypoints[indexA];
var wpB = m_Waypoints[indexB];
result = SplineHelpers.Bezier3(pos - indexA,
m_Waypoints[indexA].position, wpA.position + wpA.tangent,
wpB.position - wpB.tangent, wpB.position);
}
}
return result;
}
/// <summary>Get the tangent of the curve at a point along the path.</summary>
/// <param name="pos">Postion along the path. Need not be normalized.</param>
/// <returns>Local-space direction of the path tangent.
/// Length of the vector represents the tangent strength</returns>
public override Vector3 EvaluateLocalTangent(float pos)
{
var result = Vector3.forward;
if (m_Waypoints.Length > 0)
{
pos = GetBoundingIndices(pos, out var indexA, out var indexB);
if (indexA == indexB)
result = m_Waypoints[indexA].tangent;
else
{
var wpA = m_Waypoints[indexA];
var wpB = m_Waypoints[indexB];
result = SplineHelpers.BezierTangent3(pos - indexA,
m_Waypoints[indexA].position, wpA.position + wpA.tangent,
wpB.position - wpB.tangent, wpB.position);
}
}
return result;
}
/// <summary>Get the orientation the curve at a point along the path.</summary>
/// <param name="pos">Postion along the path. Need not be normalized.</param>
/// <returns>Local-space orientation of the path, as defined by tangent, up, and roll.</returns>
public override Quaternion EvaluateLocalOrientation(float pos)
{
var result = Quaternion.identity;
if (m_Waypoints.Length > 0)
{
pos = GetBoundingIndices(pos, out var indexA, out var indexB);
var fwd = EvaluateLocalTangent(pos);
if (!fwd.AlmostZero())
result = Quaternion.LookRotation(fwd) * RollAroundForward(GetRoll(indexA, indexB, pos));
}
return result;
}
internal float GetRoll(int indexA, int indexB, float standardizedPos)
{
if (indexA == indexB)
return m_Waypoints[indexA].roll;
float rollA = m_Waypoints[indexA].roll;
float rollB = m_Waypoints[indexB].roll;
if (indexB == 0)
{
// Special handling at the wraparound - cancel the spins
rollA %= 360;
rollB %= 360;
}
return Mathf.Lerp(rollA, rollB, standardizedPos - indexA);
}
// same as Quaternion.AngleAxis(roll, Vector3.forward), just simplified
static Quaternion RollAroundForward(float angle)
{
float halfAngle = angle * 0.5F * Mathf.Deg2Rad;
return new Quaternion(0, 0, Mathf.Sin(halfAngle), Mathf.Cos(halfAngle));
}
}
}