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