public void TestSubtractAngles()
{
Assert.IsTrue(TestUtils.Approx(CPMath.SubtractAngles(1f, 1f), 0f));
Assert.IsTrue(TestUtils.Approx(CPMath.SubtractAngles(12.3f, 2.4f), 12.3f - 2.4f - CPMath.TAU * 2f));
Assert.IsTrue(TestUtils.Approx(CPMath.SubtractAngles(2.3f, 8.4f), 2.3f - 8.4f + CPMath.TAU));
Assert.IsTrue(TestUtils.Approx(CPMath.SubtractAngles(-5.3f, 18.7f), -5.3f - 18.7f + CPMath.TAU * 4f));
}
private float SmoothStepInterpolation(float percentage)
{
int index = GetLastPointIndex(percentage);
CameraPathSpeed pointP = (CameraPathSpeed)GetPoint(index);
CameraPathSpeed pointQ = (CameraPathSpeed)GetPoint(index + 1);
if (percentage < pointP.percent)
{
return(pointP.speed);
}
if (percentage > pointQ.percent)
{
return(pointQ.speed);
}
float startPercentage = pointP.percent;
float endPercentage = pointQ.percent;
if (startPercentage > endPercentage)
{
endPercentage += 1;
}
float curveLength = endPercentage - startPercentage;
float curvePercentage = percentage - startPercentage;
float ct = curvePercentage / curveLength;
return(Mathf.Lerp(pointP.speed, pointQ.speed, CPMath.SmoothStep(ct)));
}
private Quaternion CubicInterpolation(float percentage)
{
int index = GetLastPointIndex(percentage);
CameraPathOrientation pointP = (CameraPathOrientation)GetPoint(index);
CameraPathOrientation pointQ = (CameraPathOrientation)GetPoint(index + 1);
CameraPathOrientation pointA = (CameraPathOrientation)GetPoint(index - 1);
CameraPathOrientation pointB = (CameraPathOrientation)GetPoint(index + 2);
float startPercentage = pointP.percent;
float endPercentage = pointQ.percent;
if (startPercentage > endPercentage)
{
endPercentage += 1;
}
float curveLength = endPercentage - startPercentage;
float curvePercentage = percentage - startPercentage;
float ct = curvePercentage / curveLength;
Quaternion returnQ = CPMath.CalculateCubic(pointP.rotation, pointA.rotation, pointB.rotation, pointQ.rotation, ct);
if (float.IsNaN(returnQ.x))
{
Debug.Log(percentage + " " + pointP.fullName + " " + pointQ.fullName + " " + pointA.fullName + " " + pointB.fullName);
}
return(returnQ);
}
public void TestAngleFromVector2()
{
Assert.IsTrue(TestUtils.Approx(CPMath.AngleFromVector2(Vector2.right), 0f));
Assert.IsTrue(TestUtils.Approx(CPMath.AngleFromVector2(Vector2.up), CPMath.PI * 0.5f));
Assert.IsTrue(TestUtils.Approx(CPMath.AngleFromVector2(Vector2.left), CPMath.PI));
Assert.IsTrue(TestUtils.Approx(CPMath.AngleFromVector2(Vector2.down), -CPMath.PI * 0.5f));
float angle1 = 0.132f;
Vector2 vec1 = CPMath.AngleToVector2(angle1);
Assert.IsTrue(TestUtils.Approx(CPMath.AngleFromVector2(vec1), angle1));
float angle2 = 2.834f;
Vector2 vec2 = CPMath.AngleToVector2(angle2);
Assert.IsTrue(TestUtils.Approx(CPMath.AngleFromVector2(vec2), angle2));
float angle3 = 4.324f;
Vector2 vec3 = CPMath.AngleToVector2(angle3);
Assert.IsTrue(TestUtils.Approx(CPMath.AngleFromVector2(vec3), angle3 - CPMath.TAU));
float angle4 = 6.123f;
Vector2 vec4 = CPMath.AngleToVector2(angle4);
Assert.IsTrue(TestUtils.Approx(CPMath.AngleFromVector2(vec4), angle4 - CPMath.TAU));
}
private float SmoothStepInterpolation(float percentage)
{
int index = GetLastPointIndex(percentage);
CameraPathTilt pointP = (CameraPathTilt)GetPoint(index);
CameraPathTilt pointQ = (CameraPathTilt)GetPoint(index + 1);
// if (percentage < pointP.percent)
// return pointP.tilt;
// if (percentage > pointQ.percent)
// return pointQ.tilt;
float startPercentage = pointP.percent;
float endPercentage = pointQ.percent;
if (startPercentage > endPercentage)
{
endPercentage += 1;
}
float curveLength = endPercentage - startPercentage;
float curvePercentage = percentage - startPercentage;
float ct = curvePercentage / curveLength;
return(Mathf.LerpAngle(pointP.tilt, pointQ.tilt, CPMath.SmoothStep(ct)));
}
private float SmoothStepInterpolation(float percentage)
{
int lastPointIndex = base.GetLastPointIndex(percentage);
CameraPathSpeed cameraPathSpeed = (CameraPathSpeed)base.GetPoint(lastPointIndex);
CameraPathSpeed cameraPathSpeed2 = (CameraPathSpeed)base.GetPoint(lastPointIndex + 1);
if (percentage < cameraPathSpeed.percent)
{
return(cameraPathSpeed.speed);
}
if (percentage > cameraPathSpeed2.percent)
{
return(cameraPathSpeed2.speed);
}
float percent = cameraPathSpeed.percent;
float num = cameraPathSpeed2.percent;
if (percent > num)
{
num += 1f;
}
float num2 = num - percent;
float num3 = percentage - percent;
float val = num3 / num2;
return(Mathf.Lerp(cameraPathSpeed.speed, cameraPathSpeed2.speed, CPMath.SmoothStep(val)));
}
public void TestAngleToVector2()
{
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(0f), Vector2.right));
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(CPMath.PI * 0.5f), Vector2.up));
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(CPMath.PI), Vector2.left));
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(CPMath.PI * 1.5f), Vector2.down));
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(CPMath.PI * 2f), Vector2.right));
Vector2 vec1 = new Vector2(3f, 9f);
float angle1 = CPMath.AngleFromVector2(vec1);
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(angle1), vec1.normalized));
Vector2 vec2 = new Vector2(-2.34f, 9.8f);
float angle2 = CPMath.AngleFromVector2(vec2) - CPMath.TAU;
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(angle2), vec2.normalized));
Vector2 vec3 = new Vector2(-2f, -100f);
float angle3 = CPMath.AngleFromVector2(vec3) + 2f * CPMath.TAU;
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(angle3), vec3.normalized));
Vector2 vec4 = new Vector2(3.45f, -9f);
float angle4 = CPMath.AngleFromVector2(vec4) - 3f * CPMath.TAU;
Assert.IsTrue(TestUtils.Approx(CPMath.AngleToVector2(angle4), vec4.normalized));
}
public static Quaternion LnDif(Quaternion a, Quaternion b)
{
Quaternion q = Quaternion.Inverse(a) * b;
CPMath.Normalize(q);
return(CPMath.Log(q));
}
private float SmoothStepInterpolation(float percentage)
{
int index = GetLastPointIndex(percentage);
CameraPathFOV pointP = (CameraPathFOV)GetPoint(index);
CameraPathFOV pointQ = (CameraPathFOV)GetPoint(index + 1);
// if (percentage < pointP.percent)
// return pointP.FOV;
// if (percentage > pointQ.percent)
// return pointQ.FOV;
float startPercentage = pointP.percent;
float endPercentage = pointQ.percent;
if (startPercentage > endPercentage)
{
endPercentage += 1;
}
float curveLength = endPercentage - startPercentage;
float curvePercentage = percentage - startPercentage;
float ct = curvePercentage / curveLength;
// Debug.DrawLine(cameraPath.GetPathPosition(percentage, true), pointP.worldPosition, Color.blue);
// Debug.DrawLine(cameraPath.GetPathPosition(percentage, true), pointQ.worldPosition, Color.red);
return(Mathf.Lerp(pointP.FOV, pointQ.FOV, CPMath.SmoothStep(ct)));
}
public Vector3 GetPathPosition(float percentage, bool ignoreNormalisation)
{
if (this.realNumberOfPoints < 2)
{
Debug.LogError("Not enough points to define a curve");
if (this.realNumberOfPoints == 1)
{
return(this._points.get_Item(0).worldPosition);
}
return(Vector3.get_zero());
}
else
{
if (!ignoreNormalisation)
{
percentage = this.ParsePercentage(percentage);
}
float num = 1f / (float)this.numberOfCurves;
int num2 = Mathf.FloorToInt(percentage / num);
float num3 = Mathf.Clamp01((percentage - (float)num2 * num) * (float)this.numberOfCurves);
CameraPathControlPoint point = this.GetPoint(num2);
CameraPathControlPoint point2 = this.GetPoint(num2 + 1);
if (point == null || point2 == null)
{
return(Vector3.get_zero());
}
switch (this.interpolation)
{
case CameraPath.Interpolation.Linear:
return(Vector3.Lerp(point.worldPosition, point2.worldPosition, num3));
case CameraPath.Interpolation.SmoothStep:
return(Vector3.Lerp(point.worldPosition, point2.worldPosition, CPMath.SmoothStep(num3)));
case CameraPath.Interpolation.CatmullRom:
{
CameraPathControlPoint point3 = this.GetPoint(num2 - 1);
CameraPathControlPoint point4 = this.GetPoint(num2 + 2);
return(CPMath.CalculateCatmullRom(point3.worldPosition, point.worldPosition, point2.worldPosition, point4.worldPosition, num3));
}
case CameraPath.Interpolation.Hermite:
{
CameraPathControlPoint point3 = this.GetPoint(num2 - 1);
CameraPathControlPoint point4 = this.GetPoint(num2 + 2);
return(CPMath.CalculateHermite(point3.worldPosition, point.worldPosition, point2.worldPosition, point4.worldPosition, num3, this.hermiteTension, this.hermiteBias));
}
case CameraPath.Interpolation.Bezier:
return(CPMath.CalculateBezier(num3, point.worldPosition, point.forwardControlPointWorld, point2.backwardControlPointWorld, point2.worldPosition));
default:
return(Vector3.get_zero());
}
}
}
public static Quaternion Nlerp(Quaternion p, Quaternion q, float t)
{
float num = 1f - t;
Quaternion quaternion;
quaternion.x = num * p.x + t * q.x;
quaternion.y = num * p.y + t * q.y;
quaternion.z = num * p.z + t * q.z;
quaternion.w = num * p.w + t * q.w;
CPMath.Normalize(quaternion);
return(quaternion);
}
public static Quaternion SquadTangent(Quaternion before, Quaternion center, Quaternion after)
{
Quaternion quaternion = CPMath.LnDif(center, before);
Quaternion quaternion2 = CPMath.LnDif(center, after);
Quaternion identity = Quaternion.get_identity();
for (int i = 0; i < 4; i++)
{
identity.set_Item(i, -0.25f * (quaternion.get_Item(i) + quaternion2.get_Item(i)));
}
return(center * CPMath.Exp(identity));
}
private float SmoothStepInterpolation(float percentage)
{
int lastPointIndex = base.GetLastPointIndex(percentage);
CameraPathTilt cameraPathTilt = (CameraPathTilt)base.GetPoint(lastPointIndex);
CameraPathTilt cameraPathTilt2 = (CameraPathTilt)base.GetPoint(lastPointIndex + 1);
float percent = cameraPathTilt.percent;
float num = cameraPathTilt2.percent;
if (percent > num)
{
num += 1f;
}
float num2 = num - percent;
float num3 = percentage - percent;
float val = num3 / num2;
return(Mathf.LerpAngle(cameraPathTilt.tilt, cameraPathTilt2.tilt, CPMath.SmoothStep(val)));
}
public static Quaternion CalculateCubic(Quaternion p, Quaternion a, Quaternion b, Quaternion q, float t)
{
if (Quaternion.Dot(p, q) < 0f)
{
q = new Quaternion(-q.x, -q.y, -q.z, -q.w);
}
if (Quaternion.Dot(p, a) < 0f)
{
a = new Quaternion(-a.x, -a.y, -a.z, -a.w);
}
if (Quaternion.Dot(p, b) < 0f)
{
b = new Quaternion(-b.x, -b.y, -b.z, -b.w);
}
Quaternion p2 = CPMath.SquadTangent(a, p, q);
Quaternion q2 = CPMath.SquadTangent(p, q, b);
float t2 = 2f * t * (1f - t);
return(CPMath.Slerp(CPMath.Slerp(p, q, t), CPMath.Slerp(p2, q2, t), t2));
}
private float SmoothStepInterpolation(float percentage, CameraPathFOVList.ProjectionType projectionType)
{
int lastPointIndex = base.GetLastPointIndex(percentage);
CameraPathFOV cameraPathFOV = (CameraPathFOV)base.GetPoint(lastPointIndex);
CameraPathFOV cameraPathFOV2 = (CameraPathFOV)base.GetPoint(lastPointIndex + 1);
float percent = cameraPathFOV.percent;
float num = cameraPathFOV2.percent;
if (percent > num)
{
num += 1f;
}
float num2 = num - percent;
float num3 = percentage - percent;
float val = num3 / num2;
float num4 = (projectionType != CameraPathFOVList.ProjectionType.FOV) ? cameraPathFOV.Size : cameraPathFOV.FOV;
float num5 = (projectionType != CameraPathFOVList.ProjectionType.FOV) ? cameraPathFOV2.Size : cameraPathFOV2.FOV;
return(Mathf.Lerp(num4, num5, CPMath.SmoothStep(val)));
}
public void TestSolveQuadratic()
{
Tuple <float, float> roots;
roots = CPMath.SolveQuadratic(1f, 0f, 0f);
Assert.IsTrue(TestUtils.Approx(roots.Item1, 0f));
Assert.IsTrue(TestUtils.Approx(roots.Item2, 0f));
roots = CPMath.SolveQuadratic(1f, -2f, -3f);
Assert.IsTrue(TestUtils.Approx(roots.Item1, -1f));
Assert.IsTrue(TestUtils.Approx(roots.Item2, 3f));
roots = CPMath.SolveQuadratic(-1f, -2f, 3f);
Assert.IsTrue(TestUtils.Approx(roots.Item1, -3f));
Assert.IsTrue(TestUtils.Approx(roots.Item2, 1f));
roots = CPMath.SolveQuadratic(1f, 2f, 3f);
Assert.IsNull(roots);
roots = CPMath.SolveQuadratic(-1f, -2f, -3f);
Assert.IsNull(roots);
}
private Quaternion SmootStepInterpolation(float percentage)
{
int index = GetLastPointIndex(percentage);
CameraPathOrientation pointP = (CameraPathOrientation)GetPoint(index);
CameraPathOrientation pointQ = (CameraPathOrientation)GetPoint(index + 1);
float startPercentage = pointP.percent;
float endPercentage = pointQ.percent;
if (startPercentage > endPercentage)
{
endPercentage += 1;
}
float curveLength = endPercentage - startPercentage;
float curvePercentage = percentage - startPercentage;
float ct = curvePercentage / curveLength;
Quaternion returnQ = Quaternion.Lerp(pointP.rotation, pointQ.rotation, CPMath.SmoothStep(ct));
return(returnQ);
}
private float SmoothStepInterpolation(float percentage, ProjectionType projectionType)
{
int index = GetLastPointIndex(percentage);
CameraPathFOV pointP = (CameraPathFOV)GetPoint(index);
CameraPathFOV pointQ = (CameraPathFOV)GetPoint(index + 1);
float startPercentage = pointP.percent;
float endPercentage = pointQ.percent;
if (startPercentage > endPercentage)
{
endPercentage += 1;
}
float curveLength = endPercentage - startPercentage;
float curvePercentage = percentage - startPercentage;
float ct = curvePercentage / curveLength;
float valueA = (projectionType == ProjectionType.FOV) ? pointP.FOV : pointP.Size;
float valueB = (projectionType == ProjectionType.FOV) ? pointQ.FOV : pointQ.Size;
return(Mathf.Lerp(valueA, valueB, CPMath.SmoothStep(ct)));
}
private Quaternion CubicInterpolation(float percentage)
{
int lastPointIndex = base.GetLastPointIndex(percentage);
CameraPathOrientation cameraPathOrientation = (CameraPathOrientation)base.GetPoint(lastPointIndex);
CameraPathOrientation cameraPathOrientation2 = (CameraPathOrientation)base.GetPoint(lastPointIndex + 1);
CameraPathOrientation cameraPathOrientation3 = (CameraPathOrientation)base.GetPoint(lastPointIndex - 1);
CameraPathOrientation cameraPathOrientation4 = (CameraPathOrientation)base.GetPoint(lastPointIndex + 2);
float percent = cameraPathOrientation.percent;
float num = cameraPathOrientation2.percent;
if (percent > num)
{
num += 1f;
}
float num2 = num - percent;
float num3 = percentage - percent;
float t = num3 / num2;
Quaternion result = CPMath.CalculateCubic(cameraPathOrientation.rotation, cameraPathOrientation3.rotation, cameraPathOrientation4.rotation, cameraPathOrientation2.rotation, t);
if (float.IsNaN(result.x))
{
Debug.Log(string.Concat(new object[]
{
percentage,
" ",
cameraPathOrientation.fullName,
" ",
cameraPathOrientation2.fullName,
" ",
cameraPathOrientation3.fullName,
" ",
cameraPathOrientation4.fullName
}));
result = cameraPathOrientation.rotation;
}
return(result);
}
private Quaternion SmootStepInterpolation(float percentage)
{
int lastPointIndex = base.GetLastPointIndex(percentage);
CameraPathOrientation cameraPathOrientation = (CameraPathOrientation)base.GetPoint(lastPointIndex);
CameraPathOrientation cameraPathOrientation2 = (CameraPathOrientation)base.GetPoint(lastPointIndex + 1);
float percent = cameraPathOrientation.percent;
float num = cameraPathOrientation2.percent;
if (percent > num)
{
num += 1f;
}
float num2 = num - percent;
float num3 = percentage - percent;
float val = num3 / num2;
return(Quaternion.Lerp(cameraPathOrientation.rotation, cameraPathOrientation2.rotation, CPMath.SmoothStep(val)));
}
