public float GetPathPercentage(CameraPathControlPoint pointA, CameraPathControlPoint pointB, float curvePercentage)
{
float pathPercentage = this.GetPathPercentage(pointA);
float pathPercentage2 = this.GetPathPercentage(pointB);
return(Mathf.Lerp(pathPercentage, pathPercentage2, curvePercentage));
}
/// <summary>
/// Check the free points and recalculate their values if a point have been added inside it's curve
/// </summary>
/// <param name="addedPoint">The added point to the path</param>
public void PathPointAddedEvent(CameraPathControlPoint addedPoint)
{
float pointPercentage = addedPoint.percentage;
for (int i = 0; i < realNumberOfPoints; i++)//Check freepoints have not been affected by the addition
{
CameraPathPoint point = _points[i];
if (point.positionModes == CameraPathPoint.PositionModes.Free)
{
float cPointPercentageA = point.cpointA.percentage;
float cPointPercentageB = point.cpointB.percentage;
if (pointPercentage > cPointPercentageA && pointPercentage < cPointPercentageB)
{
if (pointPercentage < point.percent)
{
//new point added before
point.cpointA = addedPoint;
}
else
{
//new point added after
point.cpointB = addedPoint;
}
cameraPath.GetCurvePercentage(point);//Recalculate free point values
}
}
}
}
private void UpdatePointReached()
{
if (this._percentage == this._lastPercentage)
{
return;
}
if (Mathf.Abs(this.percentage - this._lastPercentage) > 0.999f)
{
this._lastPercentage = this.percentage;
return;
}
for (int i = 0; i < this.cameraPath.realNumberOfPoints; i++)
{
CameraPathControlPoint cameraPathControlPoint = this.cameraPath[i];
bool flag = (cameraPathControlPoint.percentage >= this._lastPercentage && cameraPathControlPoint.percentage <= this.percentage) || (cameraPathControlPoint.percentage >= this.percentage && cameraPathControlPoint.percentage <= this._lastPercentage);
if (flag)
{
if (this.AnimationPointReachedEvent != null)
{
this.AnimationPointReachedEvent();
}
if (this.AnimationPointReachedWithNumberEvent != null)
{
this.AnimationPointReachedWithNumberEvent(i);
}
}
}
this._lastPercentage = this.percentage;
}
public void PathPointRemovedEvent(CameraPathControlPoint removedPathPoint)
{
for (int i = 0; i < this.realNumberOfPoints; i++)
{
CameraPathPoint cameraPathPoint = this._points.get_Item(i);
switch (cameraPathPoint.positionModes)
{
case CameraPathPoint.PositionModes.Free:
if (cameraPathPoint.cpointA == removedPathPoint)
{
CameraPathControlPoint point = this.cameraPath.GetPoint(removedPathPoint.index - 1);
cameraPathPoint.cpointA = point;
this.cameraPath.GetCurvePercentage(cameraPathPoint);
}
if (cameraPathPoint.cpointB == removedPathPoint)
{
CameraPathControlPoint point2 = this.cameraPath.GetPoint(removedPathPoint.index + 1);
cameraPathPoint.cpointB = point2;
this.cameraPath.GetCurvePercentage(cameraPathPoint);
}
break;
case CameraPathPoint.PositionModes.FixedToPoint:
if (cameraPathPoint.point == removedPathPoint)
{
this._points.Remove(cameraPathPoint);
i--;
}
break;
}
}
this.RecalculatePoints();
}
private void Init()
{
this.InitialiseLists();
if (this.initialised)
{
return;
}
CameraPathControlPoint cameraPathControlPoint = base.get_gameObject().AddComponent <CameraPathControlPoint>();
CameraPathControlPoint cameraPathControlPoint2 = base.get_gameObject().AddComponent <CameraPathControlPoint>();
CameraPathControlPoint cameraPathControlPoint3 = base.get_gameObject().AddComponent <CameraPathControlPoint>();
CameraPathControlPoint cameraPathControlPoint4 = base.get_gameObject().AddComponent <CameraPathControlPoint>();
cameraPathControlPoint.set_hideFlags(2);
cameraPathControlPoint2.set_hideFlags(2);
cameraPathControlPoint3.set_hideFlags(2);
cameraPathControlPoint4.set_hideFlags(2);
cameraPathControlPoint.localPosition = new Vector3(-20f, 0f, -20f);
cameraPathControlPoint2.localPosition = new Vector3(20f, 0f, -20f);
cameraPathControlPoint3.localPosition = new Vector3(20f, 0f, 20f);
cameraPathControlPoint4.localPosition = new Vector3(-20f, 0f, 20f);
cameraPathControlPoint.forwardControlPoint = new Vector3(0f, 0f, -20f);
cameraPathControlPoint2.forwardControlPoint = new Vector3(40f, 0f, -20f);
cameraPathControlPoint3.forwardControlPoint = new Vector3(0f, 0f, 20f);
cameraPathControlPoint4.forwardControlPoint = new Vector3(-40f, 0f, 20f);
this.AddPoint(cameraPathControlPoint);
this.AddPoint(cameraPathControlPoint2);
this.AddPoint(cameraPathControlPoint3);
this.AddPoint(cameraPathControlPoint4);
this.initialised = true;
}
//public virtual void FromXML(XmlNodeList nodes)
//{
// _points.Clear();
// foreach (XmlNode node in nodes)
// {
// CameraPathPoint newCameraPathPoint = gameObject.AddComponent<CameraPathPoint>();// CreateInstance<CameraPathPoint>();
// 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;
// }
// newCameraPathPoint.FromXML(node, cameraPath);
// }
//}
public virtual void FromXML(XMLNodeList nodes)
{
_points.Clear();
foreach (XMLNode node in nodes)
{
CameraPathPoint newCameraPathPoint = gameObject.AddComponent <CameraPathPoint>();// CreateInstance<CameraPathPoint>();
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;
}
newCameraPathPoint.FromXML(node, cameraPath);
}
}
//public virtual void FromXML(XmlNode node, CameraPath cameraPath)
//{
// if (node["customName"].HasChildNodes)
// customName = node["customName"].FirstChild.Value;
// index = int.Parse(node["index"].FirstChild.Value);
// positionModes = (PositionModes)System.Enum.Parse(typeof(PositionModes), node["positionModes"].FirstChild.Value);
// if (node["point"] != null)
// point = cameraPath[int.Parse(node["point"].FirstChild.Value)];
// if (node["cpointA"] != null)
// cpointA = cameraPath[int.Parse(node["cpointA"].FirstChild.Value)];
// if (node["cpointB"] != null)
// cpointB = cameraPath[int.Parse(node["cpointB"].FirstChild.Value)];
// _percent = float.Parse(node["_percent"].FirstChild.Value);
// _animationPercentage = float.Parse(node["_animationPercentage"].FirstChild.Value);
// curvePercentage = float.Parse(node["curvePercentage"].FirstChild.Value);
// worldPosition.x = float.Parse(node["worldPositionX"].FirstChild.Value);
// worldPosition.y = float.Parse(node["worldPositionY"].FirstChild.Value);
// worldPosition.z = float.Parse(node["worldPositionZ"].FirstChild.Value);
// lockPoint = bool.Parse(node["lockPoint"].FirstChild.Value);
//}
public virtual void FromXML(XMLNode node, CameraPath cameraPath)
{
if (node.GetValue("customName>0>_text") != null)
{
customName = node.GetValue("customName>0>_text");
}
index = int.Parse(node.GetValue("index>0>_text"));
positionModes = (PositionModes)System.Enum.Parse(typeof(PositionModes), node.GetValue("positionModes>0>_text"));
if (node.GetValue("point>0>_text") != null)
{
point = cameraPath[int.Parse(node.GetValue("point>0>_text"))];
}
if (node.GetValue("cpointA>0>_text") != null)
{
cpointA = cameraPath[int.Parse(node.GetValue("cpointA>0>_text"))];
}
if (node.GetValue("cpointB>0>_text") != null)
{
cpointB = cameraPath[int.Parse(node.GetValue("cpointB>0>_text"))];
}
_percent = float.Parse(node.GetValue("_percent>0>_text"));
_animationPercentage = float.Parse(node.GetValue("_animationPercentage>0>_text"));
curvePercentage = float.Parse(node.GetValue("curvePercentage>0>_text"));
worldPosition.x = float.Parse(node.GetValue("worldPositionX>0>_text"));
worldPosition.y = float.Parse(node.GetValue("worldPositionY>0>_text"));
worldPosition.z = float.Parse(node.GetValue("worldPositionZ>0>_text"));
lockPoint = bool.Parse(node.GetValue("lockPoint>0>_text"));
}
private static void RemovePathPoints()
{
if (SceneView.focusedWindow != null)
{
SceneView.focusedWindow.wantsMouseMove = true;
}
int numberOfPoints = _cameraPath.realNumberOfPoints;
Handles.color = _cameraPath.selectedPointColour;
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);
for (int i = 0; i < numberOfPoints; i++)
{
CameraPathControlPoint point = _cameraPath[i];
float pointHandleSize = HandleUtility.GetHandleSize(point.worldPosition) * HANDLE_SCALE;
Handles.Label(point.worldPosition, "Remove Point: " + point.displayName);
if (Handles.Button(point.worldPosition, mouseLookDirection, pointHandleSize, pointHandleSize, Handles.DotCap))
{
_cameraPath.RemovePoint(point);
GUI.changed = true;
return;
}
}
}
public override void FromXML(XmlNodeList nodes)
{
Clear();
foreach (XmlNode node in nodes)
{
CameraPathSpeed newCameraPathPoint = gameObject.AddComponent <CameraPathSpeed>();//CreateInstance<CameraPathSpeed>();
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;
}
newCameraPathPoint.FromXML(node, cameraPath);
}
}
protected virtual void UpdatePointReached()
{
if (_percentage == _lastPercentage)//no movement
{
return;
}
if (Mathf.Abs(percentage - _lastPercentage) > 0.999f)
{
_lastPercentage = percentage;//probable loop
return;
}
for (int i = 0; i < cameraPath.realNumberOfPoints; i++)
{
CameraPathControlPoint point = cameraPath[i];
bool eventBetweenAnimationDelta = (point.percentage >= _lastPercentage && point.percentage <= percentage) || (point.percentage >= percentage && point.percentage <= _lastPercentage);
if (eventBetweenAnimationDelta)
{
if (AnimationPointReachedEvent != null)
{
AnimationPointReachedEvent();
}
if (AnimationPointReachedWithNumberEvent != null)
{
AnimationPointReachedWithNumberEvent(i);
}
}
}
_lastPercentage = percentage;
}
public void PathPointAddedEvent(CameraPathControlPoint addedPoint)
{
float percentage = addedPoint.percentage;
for (int i = 0; i < this.realNumberOfPoints; i++)
{
CameraPathPoint cameraPathPoint = this._points.get_Item(i);
if (cameraPathPoint.positionModes == CameraPathPoint.PositionModes.Free)
{
float percentage2 = cameraPathPoint.cpointA.percentage;
float percentage3 = cameraPathPoint.cpointB.percentage;
if (percentage > percentage2 && percentage < percentage3)
{
if (percentage < cameraPathPoint.percent)
{
cameraPathPoint.cpointA = addedPoint;
}
else
{
cameraPathPoint.cpointB = addedPoint;
}
this.cameraPath.GetCurvePercentage(cameraPathPoint);
}
}
}
}
public virtual void FromXML(XmlNode node, CameraPath cameraPath)
{
if (node["customName"].HasChildNodes)
{
customName = node["customName"].FirstChild.Value;
}
index = int.Parse(node["index"].FirstChild.Value);
positionModes = (PositionModes)System.Enum.Parse(typeof(PositionModes), node["positionModes"].FirstChild.Value);
if (node["point"] != null)
{
point = cameraPath[int.Parse(node["point"].FirstChild.Value)];
}
if (node["cpointA"] != null)
{
cpointA = cameraPath[int.Parse(node["cpointA"].FirstChild.Value)];
}
if (node["cpointB"] != null)
{
cpointB = cameraPath[int.Parse(node["cpointB"].FirstChild.Value)];
}
_percent = float.Parse(node["_percent"].FirstChild.Value);
_animationPercentage = float.Parse(node["_animationPercentage"].FirstChild.Value);
curvePercentage = float.Parse(node["curvePercentage"].FirstChild.Value);
worldPosition.x = float.Parse(node["worldPositionX"].FirstChild.Value);
worldPosition.y = float.Parse(node["worldPositionY"].FirstChild.Value);
worldPosition.z = float.Parse(node["worldPositionZ"].FirstChild.Value);
lockPoint = bool.Parse(node["lockPoint"].FirstChild.Value);
}
private static void AddPathPoints()
{
if (SceneView.focusedWindow != null)
{
SceneView.focusedWindow.wantsMouseMove = true;
}
Handles.color = _cameraPath.unselectedPointColour;
int numberOfPoints = _cameraPath.realNumberOfPoints;
for (int i = 0; i < numberOfPoints; i++)
{
CameraPathControlPoint point = _cameraPath[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 Path Point");
float newPointHandleSize = HandleUtility.GetHandleSize(mouseTrackPoint) * HANDLE_SCALE;
Quaternion lookDirection = Quaternion.LookRotation(Camera.current.transform.forward);
if (Handles.Button(mouseTrackPoint, lookDirection, newPointHandleSize, newPointHandleSize, Handles.DotCap))
{
int newPointIndex = _cameraPath.GetNextPointIndex(mousePercentage, false);
CameraPathControlPoint newPoint = _cameraPath.gameObject.AddComponent <CameraPathControlPoint>();//ScriptableObject.CreateInstance<CameraPathControlPoint>();
newPoint.worldPosition = mouseTrackPoint;
_cameraPath.InsertPoint(newPoint, newPointIndex);
ChangeSelectedPointIndex(newPointIndex);
GUI.changed = true;
}
}
public void AddPoint(CameraPathPoint newPoint, CameraPathControlPoint atPoint)
{
newPoint.positionModes = CameraPathPoint.PositionModes.FixedToPoint;
newPoint.point = atPoint;
_points.Add(newPoint);
RecalculatePoints();
}
public void AddSpeedPoint(CameraPathControlPoint atPoint)
{
CameraPathSpeed point = gameObject.AddComponent<CameraPathSpeed>();//CreateInstance<CameraPathSpeed>();
point.hideFlags = HideFlags.HideInInspector;
AddPoint(point,atPoint);
RecalculatePoints();
}
public static void AlignPathPoint()
{
GameObject selected = Selection.activeGameObject;
CameraPath camPath = selected.GetComponent <CameraPath>();
CameraPathAnimator animator = selected.GetComponent <CameraPathAnimator>();
Undo.RecordObject(camPath, "Align Camera Path Point to View");
if (camPath != null && animator != null)
{
switch (animator.orientationMode)
{
case CameraPathAnimator.orientationModes.custom:
if (camPath.pointMode == CameraPath.PointModes.Orientations)
{
int selectedPoint = camPath.selectedPoint;
CameraPathOrientation point = camPath.orientationList[selectedPoint];
Camera sceneCam = SceneView.GetAllSceneCameras()[0];
Quaternion lookRotation = Quaternion.LookRotation(sceneCam.transform.forward);
point.rotation = lookRotation;
if (point.positionModes == CameraPathPoint.PositionModes.FixedToPoint)
{
CameraPathControlPoint cPoint = point.point;
cPoint.worldPosition = sceneCam.transform.position;
}
camPath.RecalculateStoredValues();
}
if (camPath.pointMode == CameraPath.PointModes.Transform || camPath.pointMode == CameraPath.PointModes.ControlPoints)
{
int selectedPoint = camPath.selectedPoint;
CameraPathControlPoint cPoint = camPath[selectedPoint];
Camera sceneCam = SceneView.GetAllSceneCameras()[0];
cPoint.worldPosition = sceneCam.transform.position;
CameraPathOrientation point = (CameraPathOrientation)camPath.orientationList.GetPoint(cPoint);
if (point != null)
{
Quaternion lookRotation = Quaternion.LookRotation(sceneCam.transform.forward);
point.rotation = lookRotation;
}
camPath.RecalculateStoredValues();
}
break;
default:
if (camPath.pointMode == CameraPath.PointModes.Transform || camPath.pointMode == CameraPath.PointModes.ControlPoints)
{
int selectedPoint = camPath.selectedPoint;
CameraPathControlPoint point = camPath[selectedPoint];
Camera sceneCam = SceneView.GetAllSceneCameras()[0];
float forwardArcLength = camPath.StoredArcLength(selectedPoint);
point.forwardControlPointLocal = sceneCam.transform.forward * (Mathf.Max(forwardArcLength, 0.1f) * 0.33f);
point.worldPosition = sceneCam.transform.position;
camPath.RecalculateStoredValues();
}
break;
}
}
}
public void AddEvent(CameraPathControlPoint atPoint)
{
CameraPathEvent cameraPathEvent = base.get_gameObject().AddComponent <CameraPathEvent>();
cameraPathEvent.set_hideFlags(2);
base.AddPoint(cameraPathEvent, atPoint);
this.RecalculatePoints();
}
public void AddSpeedPoint(CameraPathControlPoint atPoint)
{
CameraPathSpeed cameraPathSpeed = base.get_gameObject().AddComponent <CameraPathSpeed>();
cameraPathSpeed.set_hideFlags(2);
base.AddPoint(cameraPathSpeed, atPoint);
this.RecalculatePoints();
}
public void AddSpeedPoint(CameraPathControlPoint atPoint)
{
CameraPathSpeed point = gameObject.AddComponent <CameraPathSpeed>();//CreateInstance<CameraPathSpeed>();
point.hideFlags = HideFlags.HideInInspector;
AddPoint(point, atPoint);
RecalculatePoints();
}
public void AddDelayPoint(CameraPathControlPoint atPoint)
{
CameraPathDelay cameraPathDelay = base.get_gameObject().AddComponent <CameraPathDelay>();
cameraPathDelay.set_hideFlags(2);
base.AddPoint(cameraPathDelay, atPoint);
this.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 CameraPathSpeed AddSpeedPoint(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
CameraPathSpeed point = gameObject.AddComponent<CameraPathSpeed>();//CreateInstance<CameraPathSpeed>();
point.hideFlags = HideFlags.HideInInspector;
AddPoint(point, curvePointA, curvePointB, Mathf.Clamp01(curvePercetage));
RecalculatePoints();
return point;
}
public CameraPathEvent AddEvent(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
CameraPathEvent eventPoint = gameObject.AddComponent<CameraPathEvent>();//CreateInstance<CameraPathEvent>();
eventPoint.hideFlags = HideFlags.HideInInspector;
AddPoint(eventPoint, curvePointA, curvePointB, curvePercetage);
RecalculatePoints();
return eventPoint;
}
public void AddFOV(CameraPathControlPoint atPoint)
{
CameraPathFOV point = gameObject.AddComponent<CameraPathFOV>();//CreateInstance<CameraPathFOV>();
point.FOV = defaultFOV;
point.hideFlags = HideFlags.HideInInspector;
AddPoint(point,atPoint);
RecalculatePoints();
}
public CameraPathOrientation AddOrientation(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage, Quaternion rotation)
{
CameraPathOrientation orientation = gameObject.AddComponent<CameraPathOrientation>();//CreateInstance<CameraPathOrientation>();
orientation.rotation = rotation;
orientation.hideFlags = HideFlags.HideInInspector;
AddPoint(orientation, curvePointA, curvePointB, curvePercetage);
RecalculatePoints();
return orientation;
}
public void AddFOV(CameraPathControlPoint atPoint)
{
CameraPathFOV fovpoint = gameObject.AddComponent<CameraPathFOV>();
fovpoint.FOV = defaultFOV;
fovpoint.Size = defaultSize;
fovpoint.hideFlags = HideFlags.HideInInspector;
AddPoint(fovpoint, atPoint);
RecalculatePoints();
}
public void AddFOV(CameraPathControlPoint atPoint)
{
CameraPathFOV point = gameObject.AddComponent <CameraPathFOV>();//CreateInstance<CameraPathFOV>();
point.FOV = defaultFOV;
point.hideFlags = HideFlags.HideInInspector;
AddPoint(point, atPoint);
RecalculatePoints();
}
public CameraPathFOV AddFOV(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage, float fov)
{
CameraPathFOV fovpoint = gameObject.AddComponent<CameraPathFOV>();//CreateInstance<CameraPathFOV>();
fovpoint.hideFlags = HideFlags.HideInInspector;
fovpoint.FOV = fov;
AddPoint(fovpoint, curvePointA, curvePointB, curvePercetage);
RecalculatePoints();
return fovpoint;
}
public CameraPathTilt AddTilt(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage, float tilt)
{
CameraPathTilt tiltPoint = gameObject.AddComponent<CameraPathTilt>();//CreateInstance<CameraPathTilt>();
tiltPoint.tilt = tilt;
tiltPoint.hideFlags = HideFlags.HideInInspector;
AddPoint(tiltPoint, curvePointA, curvePointB, curvePercetage);
RecalculatePoints();
return tiltPoint;
}
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 CameraPathSpeed AddSpeedPoint(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
CameraPathSpeed cameraPathSpeed = base.get_gameObject().AddComponent <CameraPathSpeed>();
cameraPathSpeed.set_hideFlags(2);
base.AddPoint(cameraPathSpeed, curvePointA, curvePointB, Mathf.Clamp01(curvePercetage));
this.RecalculatePoints();
return(cameraPathSpeed);
}
/// <summary>
/// Add a point into the list specified by a point on the curve between to points
/// </summary>
/// <param name="newPoint">Add this point!</param>
/// <param name="curvePointA">On the curve from this point</param>
/// <param name="curvePointB">On the curve to this point</param>
/// <param name="curvePercetage">On the percent of this curve 0-1</param>
public void AddPoint(CameraPathPoint newPoint, CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
newPoint.positionModes = CameraPathPoint.PositionModes.Free;
newPoint.cpointA = curvePointA;
newPoint.cpointB = curvePointB;
newPoint.curvePercentage = curvePercetage;
_points.Add(newPoint);
RecalculatePoints();
}
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 CameraPathSpeed AddSpeedPoint(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
CameraPathSpeed point = gameObject.AddComponent <CameraPathSpeed>();//CreateInstance<CameraPathSpeed>();
point.hideFlags = HideFlags.HideInInspector;
AddPoint(point, curvePointA, curvePointB, Mathf.Clamp01(curvePercetage));
RecalculatePoints();
return(point);
}
public CameraPathEvent AddEvent(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
CameraPathEvent cameraPathEvent = base.get_gameObject().AddComponent <CameraPathEvent>();
cameraPathEvent.set_hideFlags(2);
base.AddPoint(cameraPathEvent, curvePointA, curvePointB, curvePercetage);
this.RecalculatePoints();
return(cameraPathEvent);
}
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 CameraPathOrientation AddOrientation(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage, Quaternion rotation)
{
CameraPathOrientation orientation = gameObject.AddComponent <CameraPathOrientation>();//CreateInstance<CameraPathOrientation>();
orientation.rotation = rotation;
orientation.hideFlags = HideFlags.HideInInspector;
AddPoint(orientation, curvePointA, curvePointB, curvePercetage);
RecalculatePoints();
return(orientation);
}
public CameraPathTilt AddTilt(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage, float tilt)
{
CameraPathTilt tiltPoint = gameObject.AddComponent <CameraPathTilt>();//CreateInstance<CameraPathTilt>();
tiltPoint.tilt = tilt;
tiltPoint.hideFlags = HideFlags.HideInInspector;
AddPoint(tiltPoint, curvePointA, curvePointB, curvePercetage);
RecalculatePoints();
return(tiltPoint);
}
public CameraPathOrientation AddOrientation(CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage, Quaternion rotation)
{
CameraPathOrientation cameraPathOrientation = base.get_gameObject().AddComponent <CameraPathOrientation>();
cameraPathOrientation.rotation = rotation;
cameraPathOrientation.set_hideFlags(2);
base.AddPoint(cameraPathOrientation, curvePointA, curvePointB, curvePercetage);
this.RecalculatePoints();
return(cameraPathOrientation);
}
public void AddOrientation(CameraPathControlPoint atPoint)
{
CameraPathOrientation orientation = gameObject.AddComponent<CameraPathOrientation>();//CreateInstance<CameraPathOrientation>();
if (atPoint.forwardControlPoint != Vector3.zero)
orientation.rotation = Quaternion.LookRotation(atPoint.forwardControlPoint);
else
orientation.rotation = Quaternion.LookRotation(cameraPath.GetPathDirection(atPoint.percentage));
orientation.hideFlags = HideFlags.HideInInspector;
AddPoint(orientation, atPoint);
RecalculatePoints();
//return orientation;
}
/// <summary>
/// Check points and recalculate their values if the point being removed affects its position
/// </summary>
/// <param name="removedPathPoint">The point that will be removed</param>
public void PathPointRemovedEvent(CameraPathControlPoint removedPathPoint)
{
for (int i = 0; i < realNumberOfPoints; i++)
{
CameraPathPoint point = _points[i];
switch(point.positionModes)
{
case CameraPathPoint.PositionModes.FixedToPercent:
//do nothing
break;
case CameraPathPoint.PositionModes.FixedToPoint://remove point if it's fixed to the removed one
if(point.point == removedPathPoint)
{
_points.Remove(point);
i--;
}
break;
case CameraPathPoint.PositionModes.Free://recalculate point curves
if(point.cpointA == removedPathPoint)
{
CameraPathControlPoint earlierPoint = cameraPath.GetPoint(removedPathPoint.index - 1);
point.cpointA = earlierPoint;
cameraPath.GetCurvePercentage(point);
}
if(point.cpointB == removedPathPoint)
{
CameraPathControlPoint laterPoint = cameraPath.GetPoint(removedPathPoint.index + 1);
point.cpointB = laterPoint;
cameraPath.GetCurvePercentage(point);
}
break;
}
}
RecalculatePoints();
}
/// <summary>
/// Check the free points and recalculate their values if a point have been added inside it's curve
/// </summary>
/// <param name="addedPoint">The added point to the path</param>
public void PathPointAddedEvent(CameraPathControlPoint addedPoint)
{
float pointPercentage = addedPoint.percentage;
for (int i = 0; i < realNumberOfPoints; i++)//Check freepoints have not been affected by the addition
{
CameraPathPoint point = _points[i];
if(point.positionModes == CameraPathPoint.PositionModes.Free)
{
float cPointPercentageA = point.cpointA.percentage;
float cPointPercentageB = point.cpointB.percentage;
if(pointPercentage > cPointPercentageA && pointPercentage < cPointPercentageB)
{
if(pointPercentage < point.percent)
//new point added before
point.cpointA = addedPoint;
else
//new point added after
point.cpointB = addedPoint;
cameraPath.GetCurvePercentage(point);//Recalculate free point values
}
}
}
}
public void AddPoint(CameraPathPoint newPoint, CameraPathControlPoint atPoint)
{
newPoint.positionModes = CameraPathPoint.PositionModes.FixedToPoint;
newPoint.point = atPoint;
_points.Add(newPoint);
RecalculatePoints();
}
/// <summary>
/// Add a point into the list specified by a point on the curve between to points
/// </summary>
/// <param name="newPoint">Add this point!</param>
/// <param name="curvePointA">On the curve from this point</param>
/// <param name="curvePointB">On the curve to this point</param>
/// <param name="curvePercetage">On the percent of this curve 0-1</param>
public void AddPoint(CameraPathPoint newPoint, CameraPathControlPoint curvePointA, CameraPathControlPoint curvePointB, float curvePercetage)
{
newPoint.positionModes = CameraPathPoint.PositionModes.Free;
newPoint.cpointA = curvePointA;
newPoint.cpointB = curvePointB;
newPoint.curvePercentage = curvePercetage;
_points.Add(newPoint);
RecalculatePoints();
}
public void CopyData(CameraPathControlPoint to)
{
to.customName = customName;
to.index = index;
to.percentage = percentage;
to.normalisedPercentage = normalisedPercentage;
to.worldPosition = worldPosition;
to.splitControlPoints = _splitControlPoints;
to.forwardControlPoint = _forwardControlPoint;
to.backwardControlPoint = _backwardControlPoint;
}
private static void AutoSetControlPoint(CameraPathControlPoint point)
{
CameraPathControlPoint point0 = _cameraPath.GetPoint(point.index - 1);
CameraPathControlPoint point1 = _cameraPath.GetPoint(point.index + 1);
float distanceA = Vector3.Distance(point.worldPosition, point0.worldPosition);
float distanceB = Vector3.Distance(point.worldPosition, point1.worldPosition);
float controlPointLength = Mathf.Min(distanceA, distanceB) * 0.33333f;
Vector3 controlPointDirection = ((point.worldPosition - point0.worldPosition) + (point1.worldPosition - point.worldPosition)).normalized;
point.forwardControlPointLocal = controlPointDirection * controlPointLength;
}
/// <summary>
/// Get the percentage on the curve between two path points
/// </summary>
/// <param name="pointA"></param>
/// <param name="pointB"></param>
/// <param name="percentage"></param>
/// <returns></returns>
public float GetCurvePercentage(CameraPathControlPoint pointA, CameraPathControlPoint pointB, float percentage)
{
float pointAPerc = GetPathPercentage(pointA);
float pointBPerc = GetPathPercentage(pointB);
if(pointAPerc == pointBPerc)
return pointAPerc;
if(pointAPerc > pointBPerc)//flip percentages if wrong way around
{
float newPointAPerc = pointBPerc;
pointBPerc = pointAPerc;
pointAPerc = newPointAPerc;
}
return Mathf.Clamp01((percentage - pointAPerc) / (pointBPerc - pointAPerc));
}
/// <summary>
/// Add a specified point to the camera path
/// </summary>
/// <param name="point"></param>
public void AddPoint(CameraPathControlPoint point)
{
_points.Add(point);
RecalculateStoredValues();
PathPointAddedEvent(point);
}
public virtual void FromXML(XmlNode node, CameraPath cameraPath)
{
if (node["customName"].HasChildNodes)
customName = node["customName"].FirstChild.Value;
index = int.Parse(node["index"].FirstChild.Value);
positionModes = (PositionModes)System.Enum.Parse(typeof(PositionModes), node["positionModes"].FirstChild.Value);
if(node["point"] != null)
point = cameraPath[int.Parse(node["point"].FirstChild.Value)];
if (node["cpointA"] != null)
cpointA = cameraPath[int.Parse(node["cpointA"].FirstChild.Value)];
if (node["cpointB"] != null)
cpointB = cameraPath[int.Parse(node["cpointB"].FirstChild.Value)];
_percent = float.Parse(node["_percent"].FirstChild.Value);
_animationPercentage = float.Parse(node["_animationPercentage"].FirstChild.Value);
curvePercentage = float.Parse(node["curvePercentage"].FirstChild.Value);
worldPosition.x = float.Parse(node["worldPositionX"].FirstChild.Value);
worldPosition.y = float.Parse(node["worldPositionY"].FirstChild.Value);
worldPosition.z = float.Parse(node["worldPositionZ"].FirstChild.Value);
lockPoint = bool.Parse(node["lockPoint"].FirstChild.Value);
}
/// <summary>
/// Insert a specified point into the camera path at an index
/// </summary>
/// <param name="point"></param>
/// <param name="index"></param>
public void InsertPoint(CameraPathControlPoint point, int index)
{
_points.Insert(index, point);
RecalculateStoredValues();
PathPointAddedEvent(point);
}
/// <summary>
/// Remove a point from the path by specify the point to remove
/// </summary>
/// <param name="point">The point you want to remove</param>
public void RemovePoint(CameraPathControlPoint point)
{
if (_points.Count < 3)
{
Debug.Log("We can't see any point in allowing you to delete any more points so we're not going to do it.");
return;
}
PathPointRemovedEvent(point);
int pointIndex = _points.IndexOf(point);
if(pointIndex == 0)
{
//check other points
float percentageCull = GetPathPercentage(1);
CheckStartPointCullEvent(percentageCull);
}
if (pointIndex == realNumberOfPoints - 1)
{
//check other points
float percentageCull = GetPathPercentage(realNumberOfPoints - 2);
CheckEndPointCullEvent(percentageCull);
}
_points.Remove(point);
RecalculateStoredValues();
}
/// <summary>
/// Get the path percentage from a curve percent between two points
/// </summary>
/// <param name="pointA"></param>
/// <param name="pointB"></param>
/// <param name="curvePercentage"></param>
/// <returns></returns>
public float GetPathPercentage(CameraPathControlPoint pointA, CameraPathControlPoint pointB, float curvePercentage)
{
float pointAPerc = GetPathPercentage(pointA);
float pointBPerc = GetPathPercentage(pointB);
return Mathf.Lerp(pointAPerc, pointBPerc, curvePercentage);
}
public CameraPathPoint GetPoint(CameraPathControlPoint atPoint)
{
int numberOfPoints = _points.Count;
if (numberOfPoints == 0)
return null;
foreach(CameraPathPoint point in _points)
{
if (point.positionModes == CameraPathPoint.PositionModes.FixedToPoint)
if(point.point == atPoint)
return point;
}
return null;
}
public void ReassignCP(CameraPathControlPoint from, CameraPathControlPoint to)
{
foreach(CameraPathPoint point in _points)
{
if(point.point == from)
point.point = to;
if(point.cpointA == from)
point.cpointA = to;
if(point.cpointB == from)
point.cpointB = to;
}
}
/// <summary>
/// Get the unnormalised percent value at a point
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public float GetPathPercentage(CameraPathControlPoint point)
{
int index = _points.IndexOf(point);
return index / (float)numberOfCurves;
}
