// Rotates radian to targetRadian, taking the shortest distance. Lerp argument is amount to rotate by.
// Note: lerp of 0.05 may be a good starting point.
public static FInt RotateTo(FInt radian, FInt targetRadian, FInt lerp)
{
// Return Target Radian if the value has been reached.
if (FInt.Abs(targetRadian - radian) <= lerp || FInt.Abs(targetRadian - radian) >= (FInt.PI * 2 - lerp))
{
return(targetRadian);
}
// Clamp / Wrap Target Radian as needed.
if (FInt.Abs(targetRadian - radian) > FInt.PI)
{
if (targetRadian < radian)
{
targetRadian += FInt.PI * 2;
}
else
{
targetRadian -= FInt.PI * 2;
}
}
// Return Radian Rotation
if (targetRadian > radian)
{
radian += lerp;
}
else
{
radian -= lerp;
}
return(radian);
}
// Rotates degree to targetDegree (between 0 and 360), taking the shortest distance. Lerp argument is amount to rotate by.
// Note: Lerp of 0.5 may be good place to start.
public static FInt RotateTo(FInt degree, FInt targetDegree, FInt lerp)
{
FInt diff = targetDegree - degree + 360;
// Return Target Degree if it's been matched.
if (FInt.Abs(diff) <= lerp)
{
return(targetDegree);
}
// Otherwise, return next step:
if (diff > 0)
{
degree += lerp;
}
else
{
degree -= lerp;
}
return(FPDegrees.Normalize(degree));
}
//// Calculate a smooth interpolation percent between the `min` and `max`
//static getSmoothStepPercent( value: number, min: number, max: number ): number {
// value = (value - min) / (max - min);
// return value * value * (3 - 2 * value);
//}
//static getSmootherStepPercent( value: number, min: number, max: number ): number {
// value = Math.max(0, Math.min(1, (value - min) / (max - min)));
// return value * value * value * (value * (value * 6 - 15) + 10);
//}
// Ease a value back and forth between two values.
public static FInt EaseBothDir(FInt val1, FInt val2, FInt weight)
{
return(val1 + FInt.Abs(FInt.Sin((weight + FInt.Create(0.75)) * FInt.PI * 2) / 2 + FInt.Create(0.5)) * (val2 - val1));
}
