/// <summary>
/// Performs a 2D linear interpolation between four values values, FracX, FracY ranges from 0-1
/// </summary>
public static FQuat BiLerp(FQuat p00, FQuat p10, FQuat p01, FQuat p11, float fracX, float fracY)
{
return(Lerp(
FQuat.Slerp_NotNormalized(p00, p10, fracX),
FQuat.Slerp_NotNormalized(p01, p11, fracX),
fracY));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="inVal">input value that corresponds to this key</param>
/// <param name="outVal">Output value of templated type</param>
public FInterpCurvePointQuat(float inVal, FQuat outVal)
{
InVal = inVal;
OutVal = outVal;
ArriveTangent = default(FQuat);
LeaveTangent = default(FQuat);
InterpMode = EInterpCurveMode.Linear;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="inVal">input value that corresponds to this key</param>
/// <param name="outVal">Output value of templated type</param>
/// <param name="arriveTangent">Tangent of curve arriving at this point. </param>
/// <param name="leaveTangent">Tangent of curve leaving from this point.</param>
/// <param name="interpMode">interpolation mode to use</param>
public FInterpCurvePointQuat(float inVal, FQuat outVal,
FQuat arriveTangent, FQuat leaveTangent, EInterpCurveMode interpMode)
{
InVal = inVal;
OutVal = outVal;
ArriveTangent = arriveTangent;
LeaveTangent = leaveTangent;
InterpMode = interpMode;
}
/// <summary>
/// Interpolate quaternion from Current to Target. Scaled by angle to Target, so it has a strong start speed and ease out.
/// </summary>
public static FQuat QInterpTo(FQuat current, FQuat target, float deltaTime, float interpSpeed)
{
// If no interp speed, jump to target value
if (interpSpeed <= 0.0f)
{
return(target);
}
// If the values are nearly equal, just return Target and assume we have reached our destination.
if (current.Equals(target))
{
return(target);
}
return(FQuat.Slerp(current, target, FMath.Clamp(interpSpeed * deltaTime, 0.0f, 1.0f)));
}
/// <summary>
/// Interpolate quaternion from Current to Target with constant step (in radians)
/// </summary>
public static FQuat QInterpConstantTo(FQuat current, FQuat target, float deltaTime, float interpSpeed)
{
// If no interp speed, jump to target value
if (interpSpeed <= 0.0f)
{
return(target);
}
// If the values are nearly equal, just return Target and assume we have reached our destination.
if (current.Equals(target))
{
return(target);
}
float deltaInterpSpeed = FMath.Clamp(deltaTime * interpSpeed, 0.0f, 1.0f);
float angularDistance = FMath.Max(SmallNumber, target.AngularDistance(current));
float alpha = FMath.Clamp(deltaInterpSpeed / angularDistance, 0.0f, 1.0f);
return(FQuat.Slerp(current, target, alpha));
}
// Special-case interpolation
/// <summary>
/// Interpolate a normal vector Current to Target, by interpolating the angle between those vectors with constant step.
/// </summary>
public static FVector VInterpNormalRotationTo(FVector current, FVector target, float deltaTime, float rotationSpeedDegrees)
{
// Find delta rotation between both normals.
FQuat deltaQuat = FQuat.FindBetween(current, target);
// Decompose into an axis and angle for rotation
FVector deltaAxis;
float deltaAngle;
deltaQuat.ToAxisAndAngle(out deltaAxis, out deltaAngle);
// Find rotation step for this frame
float rotationStepRadians = rotationSpeedDegrees * (PI / 180) * deltaTime;
if (FMath.Abs(deltaAngle) > rotationStepRadians)
{
deltaAngle = FMath.Clamp(deltaAngle, -rotationStepRadians, rotationStepRadians);
deltaQuat = new FQuat(deltaAxis, deltaAngle);
return(deltaQuat.RotateVector(current));
}
return(target);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="quat">Quaternion used to specify rotation.</param>
public FRotator(FQuat quat)
{
this = quat.Rotator();
DiagnosticCheckNaN();
}
/// <summary>
/// This actually returns the control point not a tangent. This is expected by the CubicInterp function for Quaternions
/// </summary>
public static void AutoCalcTangent(FQuat prevP, FQuat p, FQuat nextP, float tension, out FQuat outTan)
{
FQuat.CalcTangents(prevP, p, nextP, tension, out outTan);
}
/// <summary>
/// Performs a cubic interpolation - In the case of quaternions, we use a bezier like approach.
/// </summary>
/// <param name="p0">end points</param>
/// <param name="t0">tangent directions at end points</param>
/// <param name="p1">end points</param>
/// <param name="t1">tangent directions at end points</param>
/// <param name="alpha">distance along spline</param>
/// <returns>Interpolated value</returns>
public static FQuat CubicInterp(FQuat p0, FQuat t0, FQuat p1, FQuat t1, float alpha)
{
return(FQuat.Squad(p0, t0, p1, t1, alpha));
}
// Quat-specific interpolation
/// <summary>
/// Performs a linear interpolation between two values, Alpha ranges from 0-1
/// </summary>
public static FQuat Lerp(FQuat a, FQuat b, float alpha)
{
return(FQuat.Slerp(a, b, alpha));
}
