public float CheckEase(float percent)
{
float output = 1.0f;
for (int i = 0; i < realNumberOfPoints; i++)
{
CameraPathDelay eventPoint = this[i];
if (eventPoint != introPoint)
{
CameraPathDelay earlierPoint = (CameraPathDelay)GetPoint(i - 1);
float pathIntroPercent = cameraPath.GetPathPercentage(earlierPoint.percent, eventPoint.percent, 1 - eventPoint.introStartEasePercentage);
if (pathIntroPercent < percent && eventPoint.percent > percent)
{
float animCurvePercent = (percent - pathIntroPercent) / (eventPoint.percent - pathIntroPercent);
output = eventPoint.introCurve.Evaluate(animCurvePercent);
}
}
if (eventPoint != outroPoint)
{
CameraPathDelay laterPoint = (CameraPathDelay)GetPoint(i + 1);
float pathOutroPercent = cameraPath.GetPathPercentage(eventPoint.percent, laterPoint.percent, eventPoint.outroEndEasePercentage);
if (eventPoint.percent < percent && pathOutroPercent > percent)
{
float animCurvePercent = (percent - eventPoint.percent) / (pathOutroPercent - eventPoint.percent);
output = eventPoint.outroCurve.Evaluate(animCurvePercent);
}
}
}
return(Math.Max(output, MINIMUM_EASE_VALUE));
}
public float CheckEase(float percent)
{
float num = 1f;
for (int i = 0; i < base.realNumberOfPoints; i++)
{
CameraPathDelay cameraPathDelay = this[i];
if (cameraPathDelay != this.introPoint)
{
CameraPathDelay cameraPathDelay2 = (CameraPathDelay)base.GetPoint(i - 1);
float pathPercentage = this.cameraPath.GetPathPercentage(cameraPathDelay2.percent, cameraPathDelay.percent, 1f - cameraPathDelay.introStartEasePercentage);
if (pathPercentage < percent && cameraPathDelay.percent > percent)
{
float num2 = (percent - pathPercentage) / (cameraPathDelay.percent - pathPercentage);
num = cameraPathDelay.introCurve.Evaluate(num2);
}
}
if (cameraPathDelay != this.outroPoint)
{
CameraPathDelay cameraPathDelay3 = (CameraPathDelay)base.GetPoint(i + 1);
float pathPercentage2 = this.cameraPath.GetPathPercentage(cameraPathDelay.percent, cameraPathDelay3.percent, cameraPathDelay.outroEndEasePercentage);
if (cameraPathDelay.percent < percent && pathPercentage2 > percent)
{
float num3 = (percent - cameraPathDelay.percent) / (pathPercentage2 - cameraPathDelay.percent);
num = cameraPathDelay.outroCurve.Evaluate(num3);
}
}
}
return(Math.Max(num, this.MINIMUM_EASE_VALUE));
}
public float GetIntroEasePercentage(CameraPathDelay point)
{
float percent = this._delayList.GetPoint(point.index - 1).percent;
float percent2 = point.percent;
return(Mathf.Lerp(percent, percent2, 1f - point.introStartEasePercentage));
}
public void FireDelay(CameraPathDelay eventPoint)
{
if (this.CameraPathDelayEvent != null)
{
this.CameraPathDelayEvent(eventPoint.time);
}
}
public void AddDelayPoint(CameraPathControlPoint atPoint)
{
CameraPathDelay cameraPathDelay = base.get_gameObject().AddComponent <CameraPathDelay>();
cameraPathDelay.set_hideFlags(2);
base.AddPoint(cameraPathDelay, atPoint);
this.RecalculatePoints();
}
public void AddDelayPoint(CameraPathControlPoint atPoint)
{
CameraPathDelay point = gameObject.AddComponent <CameraPathDelay>();//CreateInstance<CameraPathDelay>();
point.hideFlags = HideFlags.HideInInspector;
AddPoint(point, atPoint);
RecalculatePoints();
}
public CameraPathDelay AddDelayPoint(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
CameraPathDelay point = gameObject.AddComponent <CameraPathDelay>();//CreateInstance<CameraPathDelay>();
point.hideFlags = HideFlags.HideInInspector;
AddPoint(point, curvePointA, curvePointB, curvePercetage);
RecalculatePoints();
return(point);
}
public CameraPathDelay AddDelayPoint(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
CameraPathDelay cameraPathDelay = base.get_gameObject().AddComponent <CameraPathDelay>();
cameraPathDelay.set_hideFlags(2);
base.AddPoint(cameraPathDelay, curvePointA, curvePointB, curvePercetage);
this.RecalculatePoints();
return(cameraPathDelay);
}
public float GetOutroEasePercentage(CameraPathDelay point)
{
float num = point.percent;
float num2 = this._delayList.GetPoint(point.index + 1).percent;
if (num > num2)
{
float num3 = num2;
num2 = num;
num = num3;
}
return(Mathf.Lerp(num, num2, point.outroEndEasePercentage));
}
public void CheckEvents(float percentage)
{
if (Mathf.Abs(percentage - _lastPercentage) > 0.1f)
{
_lastPercentage = percentage;//probable loop/seek
return;
}
if (_lastPercentage == percentage)
{
return;
}
for (int i = 0; i < realNumberOfPoints; i++)
{
CameraPathDelay eventPoint = this[i];
if (eventPoint == outroPoint)//outro doesn't delay stuff
{
continue;
}
if (eventPoint.percent >= _lastPercentage && eventPoint.percent <= percentage)//forward animation
{
if (eventPoint != introPoint)
{
FireDelay(eventPoint);
}
else if (eventPoint.time > 0)
{
FireDelay(eventPoint);
}
continue;
}
if (eventPoint.percent >= percentage && eventPoint.percent <= _lastPercentage)//backward animation
{
if (eventPoint != introPoint)
{
FireDelay(eventPoint);
}
else if (eventPoint.time > 0)
{
FireDelay(eventPoint);
}
continue;
}
}
_lastPercentage = percentage;
}
//public override void FromXML(XmlNodeList nodes)
//{
// Clear();
// foreach (XmlNode node in nodes)
// {
// CameraPathDelay newCameraPathPoint = gameObject.AddComponent<CameraPathDelay>();//CreateInstance<CameraPathDelay>();
// newCameraPathPoint.hideFlags = HideFlags.HideInInspector;
// CameraPathPoint.PositionModes positionModes = (CameraPathPoint.PositionModes)Enum.Parse(typeof(CameraPathPoint.PositionModes), node["positionModes"].FirstChild.Value);
// switch (positionModes)
// {
// case CameraPathPoint.PositionModes.Free:
// CameraPathControlPoint cPointA = cameraPath[int.Parse(node["cpointA"].FirstChild.Value)];
// CameraPathControlPoint cPointB = cameraPath[int.Parse(node["cpointB"].FirstChild.Value)];
// float curvePercentage = float.Parse(node["curvePercentage"].FirstChild.Value);
// AddPoint(newCameraPathPoint, cPointA, cPointB, curvePercentage);
// break;
// case CameraPathPoint.PositionModes.FixedToPoint:
// CameraPathControlPoint point = cameraPath[int.Parse(node["point"].FirstChild.Value)];
// AddPoint(newCameraPathPoint, point);
// break;
// case CameraPathPoint.PositionModes.FixedToPercent:
// switch (node["customName"].FirstChild.Value)
// {
// case "Start Point":
// _introPoint = newCameraPathPoint;
// AddPoint(newCameraPathPoint, 0);
// break;
// case "End Point":
// _outroPoint = newCameraPathPoint;
// AddPoint(newCameraPathPoint, 1);
// break;
// default:
// float atPercentage = float.Parse(node["_percent"].FirstChild.Value);
// AddPoint(newCameraPathPoint, atPercentage);
// break;
// }
// break;
// }
// newCameraPathPoint.FromXML(node, cameraPath);
// }
//}
public override void FromXML(XMLNodeList nodes)
{
Clear();
foreach (XMLNode node in nodes)
{
CameraPathDelay newCameraPathPoint = gameObject.AddComponent <CameraPathDelay>();//CreateInstance<CameraPathDelay>();
newCameraPathPoint.hideFlags = HideFlags.HideInInspector;
CameraPathPoint.PositionModes positionModes = (CameraPathPoint.PositionModes)Enum.Parse(typeof(CameraPathPoint.PositionModes), node.GetValue("positionModes>0>_text"));
switch (positionModes)
{
case CameraPathPoint.PositionModes.Free:
CameraPathControlPoint cPointA = cameraPath[int.Parse(node.GetValue("cpointA>0>_text"))];
CameraPathControlPoint cPointB = cameraPath[int.Parse(node.GetValue("cpointB>0>_text"))];
float curvePercentage = float.Parse(node.GetValue("curvePercentage>0>_text"));
AddPoint(newCameraPathPoint, cPointA, cPointB, curvePercentage);
break;
case CameraPathPoint.PositionModes.FixedToPoint:
CameraPathControlPoint point = cameraPath[int.Parse(node.GetValue("point>0>_text"))];
AddPoint(newCameraPathPoint, point);
break;
case CameraPathPoint.PositionModes.FixedToPercent:
string strCustomName = node.GetValue("customName>0>_text");
switch (strCustomName)
{
case "Start Point":
_introPoint = newCameraPathPoint;
AddPoint(newCameraPathPoint, 0);
break;
case "End Point":
_outroPoint = newCameraPathPoint;
AddPoint(newCameraPathPoint, 1);
break;
default:
float atPercentage = float.Parse(node.GetValue("_percent>0>_text"));
AddPoint(newCameraPathPoint, atPercentage);
break;
}
break;
}
newCameraPathPoint.FromXML(node, cameraPath);
}
}
public void CheckEvents(float percentage)
{
if (Mathf.Abs(percentage - this._lastPercentage) > 0.1f)
{
this._lastPercentage = percentage;
return;
}
if (this._lastPercentage == percentage)
{
return;
}
for (int i = 0; i < base.realNumberOfPoints; i++)
{
CameraPathDelay cameraPathDelay = this[i];
if (!(cameraPathDelay == this.outroPoint))
{
if (cameraPathDelay.percent >= this._lastPercentage && cameraPathDelay.percent <= percentage)
{
if (cameraPathDelay != this.introPoint)
{
this.FireDelay(cameraPathDelay);
}
else if (cameraPathDelay.time > 0f)
{
this.FireDelay(cameraPathDelay);
}
}
else if (cameraPathDelay.percent >= percentage && cameraPathDelay.percent <= this._lastPercentage)
{
if (cameraPathDelay != this.introPoint)
{
this.FireDelay(cameraPathDelay);
}
else if (cameraPathDelay.time > 0f)
{
this.FireDelay(cameraPathDelay);
}
}
}
}
this._lastPercentage = percentage;
}
public override void Init(CameraPath _cameraPath)
{
base.Init(_cameraPath);
if (!delayInitialised)
{
_introPoint = gameObject.AddComponent <CameraPathDelay>();// CreateInstance<CameraPathDelay>();
_introPoint.customName = "Start Point";
_introPoint.hideFlags = HideFlags.HideInInspector;
AddPoint(introPoint, 0);
_outroPoint = gameObject.AddComponent <CameraPathDelay>();//CreateInstance<CameraPathDelay>();
_outroPoint.customName = "End Point";
_outroPoint.hideFlags = HideFlags.HideInInspector;
AddPoint(outroPoint, 1);
RecalculatePoints();
delayInitialised = true;
}
pointTypeName = "Delay";
}
public override void Init(CameraPath _cameraPath)
{
base.Init(_cameraPath);
if(!delayInitialised)
{
_introPoint = gameObject.AddComponent<CameraPathDelay>();// CreateInstance<CameraPathDelay>();
_introPoint.customName = "Start Point";
_introPoint.hideFlags = HideFlags.HideInInspector;
AddPoint(introPoint, 0);
_outroPoint = gameObject.AddComponent<CameraPathDelay>();//CreateInstance<CameraPathDelay>();
_outroPoint.customName = "End Point";
_outroPoint.hideFlags = HideFlags.HideInInspector;
AddPoint(outroPoint, 1);
RecalculatePoints();
delayInitialised = true;
}
pointTypeName = "Delay";
}
public override void Init(CameraPath _cameraPath)
{
if (this.initialised)
{
return;
}
this.pointTypeName = "Delay";
base.Init(_cameraPath);
if (!this.delayInitialised)
{
this._introPoint = base.get_gameObject().AddComponent <CameraPathDelay>();
this._introPoint.customName = "Start Point";
this._introPoint.set_hideFlags(2);
base.AddPoint(this.introPoint, 0f);
this._outroPoint = base.get_gameObject().AddComponent <CameraPathDelay>();
this._outroPoint.customName = "End Point";
this._outroPoint.set_hideFlags(2);
base.AddPoint(this.outroPoint, 1f);
this.RecalculatePoints();
this.delayInitialised = true;
}
}
/// <summary>
/// Retrieve the ease value of any ease intros at the specified percentage
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public float GetIntroEasePercentage(CameraPathDelay point)
{
float pointAPerc = _delayList.GetPoint(point.index - 1).percent;
float pointBPerc = point.percent;
return Mathf.Lerp(pointAPerc, pointBPerc, 1-point.introStartEasePercentage);
}
/// <summary>
/// Retrieve the ease value of any ease outros at the specified percentage
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public float GetOutroEasePercentage(CameraPathDelay point)
{
float pointAPerc = point.percent;
float pointBPerc = _delayList.GetPoint(point.index + 1).percent;
if (pointAPerc > pointBPerc)//flip percentages if wrong way around
{
float newPointAPerc = pointBPerc;
pointBPerc = pointAPerc;
pointAPerc = newPointAPerc;
}
return Mathf.Lerp(pointAPerc, pointBPerc, point.outroEndEasePercentage);
}
public void FireDelay(CameraPathDelay eventPoint)
{
if (CameraPathDelayEvent != null)
CameraPathDelayEvent(eventPoint.time);
}
public override void FromXML(XmlNodeList nodes)
{
Clear();
foreach (XmlNode node in nodes)
{
CameraPathDelay newCameraPathPoint = gameObject.AddComponent<CameraPathDelay>();//CreateInstance<CameraPathDelay>();
newCameraPathPoint.hideFlags = HideFlags.HideInInspector;
CameraPathPoint.PositionModes positionModes = (CameraPathPoint.PositionModes)Enum.Parse(typeof(CameraPathPoint.PositionModes), node["positionModes"].FirstChild.Value);
switch (positionModes)
{
case CameraPathPoint.PositionModes.Free:
CameraPathControlPoint cPointA = cameraPath[int.Parse(node["cpointA"].FirstChild.Value)];
CameraPathControlPoint cPointB = cameraPath[int.Parse(node["cpointB"].FirstChild.Value)];
float curvePercentage = float.Parse(node["curvePercentage"].FirstChild.Value);
AddPoint(newCameraPathPoint, cPointA, cPointB, curvePercentage);
break;
case CameraPathPoint.PositionModes.FixedToPoint:
CameraPathControlPoint point = cameraPath[int.Parse(node["point"].FirstChild.Value)];
AddPoint(newCameraPathPoint, point);
break;
case CameraPathPoint.PositionModes.FixedToPercent:
switch (node["customName"].FirstChild.Value)
{
case "Start Point":
_introPoint = newCameraPathPoint;
AddPoint(newCameraPathPoint, 0);
break;
case "End Point":
_outroPoint = newCameraPathPoint;
AddPoint(newCameraPathPoint, 1);
break;
default:
float atPercentage = float.Parse(node["_percent"].FirstChild.Value);
AddPoint(newCameraPathPoint, atPercentage);
break;
}
break;
}
newCameraPathPoint.FromXML(node, cameraPath);
}
}
private static void SceneGUIDelayBased()
{
DisplayAtPoint();
CameraPathDelayList pointList = _cameraPath.delayList;
Camera sceneCamera = Camera.current;
int pointCount = pointList.realNumberOfPoints;
for (int i = 0; i < pointCount; i++)
{
CameraPathDelay point = pointList[i];
if (_cameraPath.enableUndo)
{
Undo.RecordObject(point, "Modifying Delay Point");
}
if (Vector3.Dot(sceneCamera.transform.forward, point.worldPosition - sceneCamera.transform.position) < 0)
{
continue;
}
string pointLabel = "";
if (point == pointList.introPoint)
{
pointLabel += "start point";
if (point.time > 0)
{
pointLabel += "\ndelay: " + point.time.ToString("F2") + " sec";
}
else
{
pointLabel += "\nNo delay";
}
}
else if (point == pointList.outroPoint)
{
pointLabel += "end point";
}
else
{
pointLabel += point.displayName;
if (point.time > 0)
{
pointLabel += "\ndelay: " + point.time.ToString("F2") + " sec";
}
else
{
pointLabel += "\ndelay indefinitely";
}
}
Handles.Label(point.worldPosition, pointLabel);
float pointHandleSize = HandleUtility.GetHandleSize(point.worldPosition) * HANDLE_SCALE;
Handles.color = (i == selectedPointIndex) ? _cameraPath.selectedPointColour : _cameraPath.unselectedPointColour;
if (Handles.Button(point.worldPosition, Quaternion.identity, pointHandleSize, pointHandleSize, Handles.DotCap))
{
ChangeSelectedPointIndex(i);
GUI.changed = true;
}
if (i == selectedPointIndex)
{
CPPSlider(point);
}
}
}
private static void SceneGUIEaseBased()
{
CameraPathDelayList pointList = _cameraPath.delayList;
Camera sceneCamera = Camera.current;
int pointCount = pointList.realNumberOfPoints;
for (int i = 0; i < pointCount; i++)
{
CameraPathDelay point = pointList[i];
if (_cameraPath.enableUndo)
{
Undo.RecordObject(point, "Modifying Ease Curves");
}
if (Vector3.Dot(sceneCamera.transform.forward, point.worldPosition - sceneCamera.transform.position) < 0)
{
continue;
}
string pointLabel = "";
if (point == pointList.introPoint)
{
pointLabel += "start point";
}
else if (point == pointList.outroPoint)
{
pointLabel += "end point";
}
else
{
pointLabel += point.displayName;
if (point.time > 0)
{
pointLabel += "\ndelay: " + point.time.ToString("F2") + " sec";
}
else
{
pointLabel += "\ndelay indefinitely";
}
}
Handles.Label(point.worldPosition, pointLabel);
float pointHandleSize = HandleUtility.GetHandleSize(point.worldPosition) * HANDLE_SCALE;
Handles.color = (i == selectedPointIndex) ? _cameraPath.selectedPointColour : _cameraPath.unselectedPointColour;
if (Handles.Button(point.worldPosition, Quaternion.identity, pointHandleSize, pointHandleSize, Handles.DotCap))
{
ChangeSelectedPointIndex(i);
GUI.changed = true;
}
// float unitPercent = 0.5f;
Vector3 easeUp = Vector3.up * _cameraPath.pathLength * 0.1f;
Handles.color = CameraPathColours.RED;
if (point != pointList.outroPoint)
{
float outroEasePointPercent = _cameraPath.GetOutroEasePercentage(point);
Vector3 outroEasePoint = _cameraPath.GetPathPosition(outroEasePointPercent, true);
Vector3 outroeaseDirection = _cameraPath.GetPathDirection(outroEasePointPercent, false);
Handles.Label(outroEasePoint, "Ease Out\n" + point.displayName);
Vector3 newPosition = Handles.Slider(outroEasePoint, outroeaseDirection);
float movement = Vector3.Distance(outroEasePoint, newPosition);
if (movement > Mathf.Epsilon)
{
float newPercent = NearestmMousePercentage();
float curvePercent = _cameraPath.GetCurvePercentage(_cameraPath.delayList.GetPoint(point.index), _cameraPath.delayList.GetPoint(point.index + 1), newPercent);
point.outroEndEasePercentage = curvePercent;
}
float percentWidth = (outroEasePointPercent - point.percent);
// float easeSpace = _cameraPath.pathLength * percentWidth;
// float easeLength = unitPercent / percentWidth;
float percentMovement = percentWidth / 10.0f;
for (float e = point.percent; e < outroEasePointPercent; e += percentMovement)
{
float eB = e + percentMovement;
Vector3 lineStart = _cameraPath.GetPathPosition(e, true);
Vector3 lineEnd = _cameraPath.GetPathPosition(eB, true);
Handles.DrawLine(lineStart, lineEnd);
float animCurvePercentA = (e - point.percent) / percentWidth;
float animCurvePercentB = (eB - point.percent) / percentWidth;
Vector3 lineEaseUpA = easeUp * point.outroCurve.Evaluate(animCurvePercentA);
Vector3 lineEaseUpB = easeUp * point.outroCurve.Evaluate(animCurvePercentB);
Handles.DrawLine(lineStart + lineEaseUpA, lineEnd + lineEaseUpB);
}
}
if (point != pointList.introPoint)
{
float introEasePointPercent = _cameraPath.GetIntroEasePercentage(point);
Vector3 introEasePoint = _cameraPath.GetPathPosition(introEasePointPercent, true);
Vector3 introEaseDirection = _cameraPath.GetPathDirection(introEasePointPercent, false);
Handles.color = CameraPathColours.RED;
Handles.Label(introEasePoint, "Ease In\n" + point.displayName);
Vector3 newPosition = Handles.Slider(introEasePoint, -introEaseDirection);
float movement = Vector3.Distance(introEasePoint, newPosition);
if (movement > Mathf.Epsilon)
{
float newPercent = NearestmMousePercentage();
float curvePercent = 1 - _cameraPath.GetCurvePercentage(_cameraPath.delayList.GetPoint(point.index - 1), _cameraPath.delayList.GetPoint(point.index), newPercent);
point.introStartEasePercentage = curvePercent;
}
float percentWidth = (point.percent - introEasePointPercent);
// float easeSpace = _cameraPath.pathLength * percentWidth;
// float easeLength = unitPercent / percentWidth;
float percentMovement = percentWidth / 10.0f;
for (float e = introEasePointPercent; e < point.percent; e += percentMovement)
{
float eB = e + percentMovement;
Vector3 lineStart = _cameraPath.GetPathPosition(e, true);
Vector3 lineEnd = _cameraPath.GetPathPosition(eB, true);
Handles.DrawLine(lineStart, lineEnd);
float animCurvePercentA = (e - introEasePointPercent) / percentWidth;
float animCurvePercentB = (eB - introEasePointPercent) / percentWidth;
Vector3 lineEaseUpA = easeUp * point.introCurve.Evaluate(animCurvePercentA);
Vector3 lineEaseUpB = easeUp * point.introCurve.Evaluate(animCurvePercentB);
Handles.DrawLine(lineStart + lineEaseUpA, lineEnd + lineEaseUpB);
}
}
}
}
private static void AddCPathPoints()
{
if (SceneView.focusedWindow != null)
{
SceneView.focusedWindow.wantsMouseMove = true;
}
Handles.color = _cameraPath.selectedPointColour;
CameraPathPointList pointList = null;
switch (_pointMode)
{
case CameraPath.PointModes.AddOrientations:
pointList = _cameraPath.orientationList;
break;
case CameraPath.PointModes.AddFovs:
pointList = _cameraPath.fovList;
break;
case CameraPath.PointModes.AddTilts:
pointList = _cameraPath.tiltList;
break;
case CameraPath.PointModes.AddEvents:
pointList = _cameraPath.eventList;
break;
case CameraPath.PointModes.AddSpeeds:
pointList = _cameraPath.speedList;
break;
case CameraPath.PointModes.AddDelays:
pointList = _cameraPath.delayList;
break;
}
int numberOfPoints = pointList.realNumberOfPoints;
for (int i = 0; i < numberOfPoints; i++)
{
CameraPathPoint point = pointList[i];
float pointHandleSize = HandleUtility.GetHandleSize(point.worldPosition) * HANDLE_SCALE * 0.4f;
Handles.DotCap(0, point.worldPosition, Quaternion.identity, pointHandleSize);
}
float mousePercentage = NearestmMousePercentage();// _track.GetNearestPoint(mousePlanePoint);
Vector3 mouseTrackPoint = _cameraPath.GetPathPosition(mousePercentage, true);
Handles.Label(mouseTrackPoint, "Add New Point");
float newPointHandleSize = HandleUtility.GetHandleSize(mouseTrackPoint) * HANDLE_SCALE;
Ray mouseRay = Camera.current.ScreenPointToRay(new Vector3(Event.current.mousePosition.x, Screen.height - Event.current.mousePosition.y - 30, 0));
Quaternion mouseLookDirection = Quaternion.LookRotation(-mouseRay.direction);
if (Handles.Button(mouseTrackPoint, mouseLookDirection, newPointHandleSize, newPointHandleSize, Handles.DotCap))
{
CameraPathControlPoint curvePointA = _cameraPath[_cameraPath.GetLastPointIndex(mousePercentage, false)];
CameraPathControlPoint curvePointB = _cameraPath[_cameraPath.GetNextPointIndex(mousePercentage, false)];
float curvePercentage = _cameraPath.GetCurvePercentage(curvePointA, curvePointB, mousePercentage);
switch (_pointMode)
{
case CameraPath.PointModes.AddOrientations:
Quaternion pointRotation = Quaternion.LookRotation(_cameraPath.GetPathDirection(mousePercentage));
CameraPathOrientation newOrientation = ((CameraPathOrientationList)pointList).AddOrientation(curvePointA, curvePointB, curvePercentage, pointRotation);
ChangeSelectedPointIndex(pointList.IndexOf(newOrientation));
break;
case CameraPath.PointModes.AddFovs:
float pointFOV = _cameraPath.fovList.GetValue(mousePercentage, CameraPathFOVList.ProjectionType.FOV);
float pointSize = _cameraPath.fovList.GetValue(mousePercentage, CameraPathFOVList.ProjectionType.Orthographic);
CameraPathFOV newFOVPoint = ((CameraPathFOVList)pointList).AddFOV(curvePointA, curvePointB, curvePercentage, pointFOV, pointSize);
ChangeSelectedPointIndex(pointList.IndexOf(newFOVPoint));
break;
case CameraPath.PointModes.AddTilts:
float pointTilt = _cameraPath.GetPathTilt(mousePercentage);
CameraPathTilt newTiltPoint = ((CameraPathTiltList)pointList).AddTilt(curvePointA, curvePointB, curvePercentage, pointTilt);
ChangeSelectedPointIndex(pointList.IndexOf(newTiltPoint));
break;
case CameraPath.PointModes.AddEvents:
CameraPathEvent newEventPoint = ((CameraPathEventList)pointList).AddEvent(curvePointA, curvePointB, curvePercentage);
ChangeSelectedPointIndex(pointList.IndexOf(newEventPoint));
break;
case CameraPath.PointModes.AddSpeeds:
_cameraPath.speedList.listEnabled = true; //if we're adding speeds then we probable want to enable it
CameraPathSpeed newSpeedPoint = ((CameraPathSpeedList)pointList).AddSpeedPoint(curvePointA, curvePointB, curvePercentage);
newSpeedPoint.speed = _animator.pathSpeed;
ChangeSelectedPointIndex(pointList.IndexOf(newSpeedPoint));
break;
case CameraPath.PointModes.AddDelays:
CameraPathDelay newDelayPoint = ((CameraPathDelayList)pointList).AddDelayPoint(curvePointA, curvePointB, curvePercentage);
ChangeSelectedPointIndex(pointList.IndexOf(newDelayPoint));
break;
}
GUI.changed = true;
}
}
