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))); }