public void AddPoint(CameraPathPoint newPoint, float fixPercent)
{
newPoint.positionModes = CameraPathPoint.PositionModes.FixedToPercent;
newPoint.percent = fixPercent;
_points.Add(newPoint);
RecalculatePoints();
}
public void AddPoint(CameraPathPoint newPoint, CameraPathControlPoint atPoint)
{
newPoint.positionModes = CameraPathPoint.PositionModes.FixedToPoint;
newPoint.point = atPoint;
_points.Add(newPoint);
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 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 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();
}
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);
}
}
}
}
/// <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();
}
private static void RemoveCPathPoints()
{
if (SceneView.focusedWindow != null)
{
SceneView.focusedWindow.wantsMouseMove = true;
}
CameraPathPointList pointList = null;
switch (_pointMode)
{
case CameraPath.PointModes.RemoveOrientations:
pointList = _cameraPath.orientationList;
break;
case CameraPath.PointModes.RemoveFovs:
pointList = _cameraPath.fovList;
break;
case CameraPath.PointModes.RemoveTilts:
pointList = _cameraPath.tiltList;
break;
case CameraPath.PointModes.RemoveEvents:
pointList = _cameraPath.eventList;
break;
case CameraPath.PointModes.RemoveSpeeds:
pointList = _cameraPath.speedList;
break;
case CameraPath.PointModes.RemoveDelays:
pointList = _cameraPath.delayList;
break;
}
int numberOfPoints = pointList.realNumberOfPoints;
Handles.color = _cameraPath.selectedPointColour;
Quaternion mouseLookDirection = Quaternion.LookRotation(Camera.current.transform.forward);
for (int i = 0; i < numberOfPoints; i++)
{
CameraPathPoint point = pointList[i];
float pointHandleSize = HandleUtility.GetHandleSize(point.worldPosition) * HANDLE_SCALE;
Handles.Label(point.worldPosition, "Remove Point " + i);
if (Handles.Button(point.worldPosition, mouseLookDirection, pointHandleSize, pointHandleSize, Handles.DotCap))
{
pointList.RemovePoint(point);
GUI.changed = true;
return;
}
}
}
public float GetCurvePercentage(CameraPathPoint pointA, CameraPathPoint pointB, float percentage)
{
float num = pointA.percent;
float num2 = pointB.percent;
if (num > num2)
{
float num3 = num2;
num2 = num;
num = num3;
}
return(Mathf.Clamp01((percentage - num) / (num2 - num)));
}
public float GetCurvePercentage(CameraPathPoint point)
{
float num = this.GetPathPercentage(point.cpointA);
float num2 = this.GetPathPercentage(point.cpointB);
if (num > num2)
{
float num3 = num2;
num2 = num;
num = num3;
}
point.curvePercentage = Mathf.Clamp01((point.percent - num) / (num2 - num));
return(point.curvePercentage);
}
private static void CPPSlider(CameraPathPoint point)
{
if (point.positionModes == CameraPathPoint.PositionModes.FixedToPercent)
{
return;//can't move fixed points
}
Vector3 pointPathDirection = _cameraPath.GetPathDirection(point.percent, false);
Handles.color = CameraPathColours.BLUE;
Vector3 newPosition = Handles.Slider(point.worldPosition, pointPathDirection);
newPosition = Handles.Slider(newPosition, -pointPathDirection);
float movement = Vector3.Distance(point.worldPosition, newPosition);
if (movement > Mathf.Epsilon)
{
//float newPercent = _cameraPath.GetNearestPoint(newPosition, false);
float newPercent = NearestmMousePercentage();
switch (point.positionModes)
{
case CameraPathPoint.PositionModes.Free:
CameraPathControlPoint curvePointA = _cameraPath[_cameraPath.GetLastPointIndex(newPercent, false)];
CameraPathControlPoint curvePointB = _cameraPath[_cameraPath.GetNextPointIndex(newPercent, false)];
point.cpointA = curvePointA;
point.cpointB = curvePointB;
point.curvePercentage = _cameraPath.GetCurvePercentage(curvePointA, curvePointB, newPercent);
break;
case CameraPathPoint.PositionModes.FixedToPoint:
point.positionModes = CameraPathPoint.PositionModes.Free;
CameraPathControlPoint newCurvePointA = _cameraPath[_cameraPath.GetLastPointIndex(newPercent, false)];
CameraPathControlPoint newCurvePointB = _cameraPath[_cameraPath.GetNextPointIndex(newPercent, false)];
if (newCurvePointA == newCurvePointB)
{
newCurvePointB = _cameraPath[_cameraPath.GetPointIndex(newCurvePointB.index - 1)];
}
point.cpointA = newCurvePointA;
point.cpointB = newCurvePointB;
point.curvePercentage = _cameraPath.GetCurvePercentage(newCurvePointA, newCurvePointB, newPercent);
break;
}
point.worldPosition = _cameraPath.GetPathPosition(point.percent, false);
_cameraPath.RecalculateStoredValues();
selectedPointIndex = point.index;
}
}
public CameraPathPoint GetPoint(CameraPathControlPoint atPoint)
{
if (this._points.get_Count() == 0)
{
return(null);
}
using (List <CameraPathPoint> .Enumerator enumerator = this._points.GetEnumerator())
{
while (enumerator.MoveNext())
{
CameraPathPoint current = enumerator.get_Current();
if (current.positionModes == CameraPathPoint.PositionModes.FixedToPoint && current.point == atPoint)
{
return(current);
}
}
}
return(null);
}
public void CheckPointCullEventFromEnd(float percent)
{
int num = this._points.get_Count();
for (int i = 0; i < num; i++)
{
CameraPathPoint cameraPathPoint = this._points.get_Item(i);
if (cameraPathPoint.positionModes != CameraPathPoint.PositionModes.FixedToPercent)
{
if (cameraPathPoint.percent > percent)
{
this._points.Remove(cameraPathPoint);
i--;
num--;
}
}
}
this.RecalculatePoints();
}
public void CheckPointCullEventFromEnd(float percent)
{
int numberOfPoints = _points.Count;
for (int i = 0; i < numberOfPoints; i++)
{
CameraPathPoint point = _points[i];
if (point.positionModes == CameraPathPoint.PositionModes.FixedToPercent)
{
continue;//nothing affects these points
}
if (point.percent > percent)
{
_points.Remove(point);
i--;
numberOfPoints--;
}
}
RecalculatePoints();
}
public CameraPathPoint DuplicatePointCheck()
{
using (List <CameraPathPoint> .Enumerator enumerator = this._points.GetEnumerator())
{
while (enumerator.MoveNext())
{
CameraPathPoint current = enumerator.get_Current();
using (List <CameraPathPoint> .Enumerator enumerator2 = this._points.GetEnumerator())
{
while (enumerator2.MoveNext())
{
CameraPathPoint current2 = enumerator2.get_Current();
if (current != current2 && current.percent == current2.percent)
{
return(current);
}
}
}
}
}
return(null);
}
public void ReassignCP(CameraPathControlPoint from, CameraPathControlPoint to)
{
using (List <CameraPathPoint> .Enumerator enumerator = this._points.GetEnumerator())
{
while (enumerator.MoveNext())
{
CameraPathPoint current = enumerator.get_Current();
if (current.point == from)
{
current.point = to;
}
if (current.cpointA == from)
{
current.cpointA = to;
}
if (current.cpointB == from)
{
current.cpointB = to;
}
}
}
}
/// <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();
}
public void AddPoint(CameraPathPoint newPoint, float fixPercent)
{
newPoint.positionModes = CameraPathPoint.PositionModes.FixedToPercent;
newPoint.percent = fixPercent;
_points.Add(newPoint);
RecalculatePoints();
}
/// <summary>
/// Get the index of a given point
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public int IndexOf(CameraPathPoint point)
{
return _points.IndexOf(point);
}
/// <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();
}
/// <summary>
/// Calculate the curve percenteage of a point
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public float GetCurvePercentage(CameraPathPoint point)
{
float pointAPerc = GetPathPercentage(point.cpointA);
float pointBPerc = GetPathPercentage(point.cpointB);
if (pointAPerc > pointBPerc)//flip percentages if wrong way around
{
float newPointAPerc = pointBPerc;
pointBPerc = pointAPerc;
pointAPerc = newPointAPerc;
}
point.curvePercentage = Mathf.Clamp01((point.percent - pointAPerc) / (pointBPerc - pointAPerc));
return point.curvePercentage;
}
private static void CPPSlider(CameraPathPoint point)
{
if(point.positionModes == CameraPathPoint.PositionModes.FixedToPercent)
return;//can't move fixed points
Vector3 pointPathDirection = _cameraPath.GetPathDirection(point.percent, false);
Handles.color = CameraPathColours.BLUE;
Vector3 newPosition = Handles.Slider(point.worldPosition, pointPathDirection);
newPosition = Handles.Slider(newPosition, -pointPathDirection);
float movement = Vector3.Distance(point.worldPosition, newPosition);
if (movement > Mathf.Epsilon)
{
//float newPercent = _cameraPath.GetNearestPoint(newPosition, false);
float newPercent = NearestmMousePercentage();
switch(point.positionModes)
{
case CameraPathPoint.PositionModes.Free:
CameraPathControlPoint curvePointA = _cameraPath[_cameraPath.GetLastPointIndex(newPercent, false)];
CameraPathControlPoint curvePointB = _cameraPath[_cameraPath.GetNextPointIndex(newPercent, false)];
point.cpointA = curvePointA;
point.cpointB = curvePointB;
point.curvePercentage = _cameraPath.GetCurvePercentage(curvePointA, curvePointB, newPercent);
break;
case CameraPathPoint.PositionModes.FixedToPoint:
point.positionModes = CameraPathPoint.PositionModes.Free;
CameraPathControlPoint newCurvePointA = _cameraPath[_cameraPath.GetLastPointIndex(newPercent, false)];
CameraPathControlPoint newCurvePointB = _cameraPath[_cameraPath.GetNextPointIndex(newPercent, false)];
if(newCurvePointA == newCurvePointB)
newCurvePointB = _cameraPath[_cameraPath.GetPointIndex(newCurvePointB.index- 1)];
point.cpointA = newCurvePointA;
point.cpointB = newCurvePointB;
point.curvePercentage = _cameraPath.GetCurvePercentage(newCurvePointA, newCurvePointB, newPercent);
break;
}
point.worldPosition = _cameraPath.GetPathPosition(point.percent, false);
_cameraPath.RecalculateStoredValues();
selectedPointIndex = point.index;
}
}
//lsy add
public CameraPathSpeed AddSpeedPoint(CameraPathPoint.PositionModes positionModes, int pointIndex, int curvePointA, int curvePointB, float curvePercentage)
{
//Debug.Log("------------AddSpeedPoint--------------");
CameraPathSpeed newSpeedPoint = _cameraPath.gameObject.AddComponent<CameraPathSpeed>();//CreateInstance<CameraPathSpeed>();
newSpeedPoint.hideFlags = HideFlags.HideInInspector;
////////AddPoint(point, curvePointA, curvePointB, Mathf.Clamp01(curvePercetage));
////////RecalculatePoints();
switch (positionModes)
{
case CameraPathPoint.PositionModes.Free:
CameraPathControlPoint cPointA = _cameraPath[curvePointA];
CameraPathControlPoint cPointB = _cameraPath[curvePointB];
float CurvePercentage = curvePercentage;
_cameraPath.speedList.AddPoint(newSpeedPoint, cPointA, cPointB, Mathf.Clamp01(CurvePercentage));
break;
case CameraPathPoint.PositionModes.FixedToPoint:
CameraPathControlPoint point = _cameraPath[pointIndex];
_cameraPath.speedList.AddPoint(newSpeedPoint, point);
break;
default:
break;
}
return newSpeedPoint;
}
/// <summary>
/// Get the percentage of the curve between two points
/// </summary>
/// <param name="pointA"></param>
/// <param name="pointB"></param>
/// <param name="percentage"></param>
/// <returns></returns>
public float GetCurvePercentage(CameraPathPoint pointA, CameraPathPoint pointB, float percentage)
{
float pointAPerc = pointA.percent;
float pointBPerc = pointB.percent;
if (pointAPerc > pointBPerc)//flip percentages if wrong way around
{
float newPointAPerc = pointBPerc;
pointBPerc = pointAPerc;
pointAPerc = newPointAPerc;
}
return Mathf.Clamp01((percentage - pointAPerc) / (pointBPerc - pointAPerc));
}
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;
}
}
protected virtual void RecalculatePoints()
{
if (cameraPath == null)
{
Debug.LogError("Camera Path Point List was not initialised - run Init();");
return;
}
int numberOfPoints = _points.Count;
if (numberOfPoints == 0)
{
//no points to recalculate
return;
}
List <CameraPathPoint> newPointList = new List <CameraPathPoint>()
{
};
for (int i = 0; i < numberOfPoints; i++)
{
if (_points[i] == null)
{
continue;
}
CameraPathPoint point = _points[i];
if (i == 0)
{
newPointList.Add(point);
continue;
}
bool pointAdded = false;
foreach (CameraPathPoint listPoint in newPointList)
{
if (listPoint.percent > point.percent)
{
newPointList.Insert(newPointList.IndexOf(listPoint), point);
pointAdded = true;
break;
}
}
if (!pointAdded)
{
newPointList.Add(point);
}
}
numberOfPoints = newPointList.Count;
_points = newPointList;
for (int i = 0; i < numberOfPoints; i++)
{
CameraPathPoint point = _points[i];
point.givenName = pointTypeName + " Point " + i;
point.fullName = cameraPath.name + " " + pointTypeName + " Point " + i;
point.index = i;
if (cameraPath.realNumberOfPoints >= 2)
{
switch (point.positionModes)
{
case CameraPathPoint.PositionModes.Free:
if (point.cpointA == point.cpointB)
{
point.positionModes = CameraPathPoint.PositionModes.FixedToPoint;
point.point = point.cpointA;
point.cpointA = null;
point.cpointB = null;
point.percent = point.point.percentage;
point.animationPercentage = (cameraPath.normalised) ? point.point.normalisedPercentage : point.point.percentage;
point.worldPosition = point.point.worldPosition;
return;
}
point.percent = cameraPath.GetPathPercentage(point.cpointA, point.cpointB, point.curvePercentage);
point.animationPercentage = (cameraPath.normalised) ? cameraPath.CalculateNormalisedPercentage(point.percent) : point.percent;
point.worldPosition = cameraPath.GetPathPosition(point.percent, true);
break;
case CameraPathPoint.PositionModes.FixedToPercent:
point.worldPosition = cameraPath.GetPathPosition(point.percent, true);
point.animationPercentage = (cameraPath.normalised) ? cameraPath.CalculateNormalisedPercentage(point.percent) : point.percent;
break;
case CameraPathPoint.PositionModes.FixedToPoint:
if (point.point == null)
{
point.point = cameraPath[cameraPath.GetNearestPointIndex(point.rawPercent)];
}
point.percent = point.point.percentage;
point.animationPercentage = (cameraPath.normalised) ? point.point.normalisedPercentage : point.point.percentage;
point.worldPosition = point.point.worldPosition;
break;
}
}
}
}
public void AddPoint(CameraPathPoint newPoint, CameraPathControlPoint atPoint)
{
newPoint.positionModes = CameraPathPoint.PositionModes.FixedToPoint;
newPoint.point = atPoint;
_points.Add(newPoint);
RecalculatePoints();
}
public CameraPathOrientation AddOrientationsPoint(CameraPathPoint.PositionModes positionModes, Quaternion pointRotation, int pointIndex, int cpointA, int cpointB, float curvepercentage)
{
// Debug.Log("AddOrientationsPoint:" + positionModes + ":" + pointIndex + ":" + cpointA + ":" + cpointB + ":" + curvepercentage);
CameraPathOrientation newCameraPathPoint = _cameraPath.gameObject.AddComponent<CameraPathOrientation>();//CreateInstance<CameraPathOrientation>();
newCameraPathPoint.hideFlags = HideFlags.HideInInspector;
//CameraPathPoint.PositionModes positionModes = positionModes;
switch (positionModes)
{
case CameraPathPoint.PositionModes.Free:
CameraPathControlPoint cPointA = _cameraPath[cpointA];
CameraPathControlPoint cPointB = _cameraPath[cpointB];
float curvePercentage = curvepercentage;
_cameraPath.orientationList.AddPoint(newCameraPathPoint, cPointA, cPointB, curvePercentage);
break;
case CameraPathPoint.PositionModes.FixedToPoint:
CameraPathControlPoint point = _cameraPath[pointIndex];
_cameraPath.orientationList.AddPoint(newCameraPathPoint, point);
break;
}
//newCameraPathPoint.rotation = pointRotation;
return newCameraPathPoint;
}
public void RemovePoint(CameraPathPoint newPoint)
{
_points.Remove(newPoint);
RecalculatePoints();
}
/// <summary>
/// Get the index of a given point
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public int IndexOf(CameraPathPoint point)
{
return(_points.IndexOf(point));
}
protected virtual void RecalculatePoints()
{
if (this.cameraPath == null)
{
Debug.LogError("Camera Path Point List was not initialised - run Init();");
return;
}
int count = this._points.get_Count();
if (count == 0)
{
return;
}
List <CameraPathPoint> list = new List <CameraPathPoint>();
for (int i = 0; i < count; i++)
{
if (!(this._points.get_Item(i) == null))
{
CameraPathPoint cameraPathPoint = this._points.get_Item(i);
if (i == 0)
{
list.Add(cameraPathPoint);
}
else
{
bool flag = false;
using (List <CameraPathPoint> .Enumerator enumerator = list.GetEnumerator())
{
while (enumerator.MoveNext())
{
CameraPathPoint current = enumerator.get_Current();
if (current.percent > cameraPathPoint.percent)
{
list.Insert(list.IndexOf(current), cameraPathPoint);
flag = true;
break;
}
}
}
if (!flag)
{
list.Add(cameraPathPoint);
}
}
}
}
count = list.get_Count();
this._points = list;
for (int j = 0; j < count; j++)
{
CameraPathPoint cameraPathPoint2 = this._points.get_Item(j);
cameraPathPoint2.givenName = this.pointTypeName + " Point " + j;
cameraPathPoint2.fullName = string.Concat(new object[]
{
this.cameraPath.get_name(),
" ",
this.pointTypeName,
" Point ",
j
});
cameraPathPoint2.index = j;
if (this.cameraPath.realNumberOfPoints >= 2)
{
switch (cameraPathPoint2.positionModes)
{
case CameraPathPoint.PositionModes.Free:
if (cameraPathPoint2.cpointA == cameraPathPoint2.cpointB)
{
cameraPathPoint2.positionModes = CameraPathPoint.PositionModes.FixedToPoint;
cameraPathPoint2.point = cameraPathPoint2.cpointA;
cameraPathPoint2.cpointA = null;
cameraPathPoint2.cpointB = null;
cameraPathPoint2.percent = cameraPathPoint2.point.percentage;
cameraPathPoint2.animationPercentage = ((!this.cameraPath.normalised) ? cameraPathPoint2.point.percentage : cameraPathPoint2.point.normalisedPercentage);
cameraPathPoint2.worldPosition = cameraPathPoint2.point.worldPosition;
return;
}
cameraPathPoint2.percent = this.cameraPath.GetPathPercentage(cameraPathPoint2.cpointA, cameraPathPoint2.cpointB, cameraPathPoint2.curvePercentage);
cameraPathPoint2.animationPercentage = ((!this.cameraPath.normalised) ? cameraPathPoint2.percent : this.cameraPath.CalculateNormalisedPercentage(cameraPathPoint2.percent));
cameraPathPoint2.worldPosition = this.cameraPath.GetPathPosition(cameraPathPoint2.percent, true);
break;
case CameraPathPoint.PositionModes.FixedToPoint:
if (cameraPathPoint2.point == null)
{
cameraPathPoint2.point = this.cameraPath[this.cameraPath.GetNearestPointIndex(cameraPathPoint2.rawPercent)];
}
cameraPathPoint2.percent = cameraPathPoint2.point.percentage;
cameraPathPoint2.animationPercentage = ((!this.cameraPath.normalised) ? cameraPathPoint2.point.percentage : cameraPathPoint2.point.normalisedPercentage);
cameraPathPoint2.worldPosition = cameraPathPoint2.point.worldPosition;
break;
case CameraPathPoint.PositionModes.FixedToPercent:
cameraPathPoint2.worldPosition = this.cameraPath.GetPathPosition(cameraPathPoint2.percent, true);
cameraPathPoint2.animationPercentage = ((!this.cameraPath.normalised) ? cameraPathPoint2.percent : this.cameraPath.CalculateNormalisedPercentage(cameraPathPoint2.percent));
break;
}
}
}
}
public void RemovePoint(CameraPathPoint newPoint)
{
_points.Remove(newPoint);
RecalculatePoints();
}
public static void OnSceneGUI()
{
if (!_cameraPath.showGizmos)
{
return;
}
if (_cameraPath.transform.rotation != Quaternion.identity)
{
return;
}
_pointMode = _cameraPath.pointMode;
if (SceneView.focusedWindow != null)
{
SceneView.focusedWindow.wantsMouseMove = false;
}
//draw small point indicators
Handles.color = CameraPathColours.GREY;
int numberOfCPoints = _cameraPath.fovList.realNumberOfPoints;
for (int i = 0; i < numberOfCPoints; i++)
{
CameraPathPoint point = _cameraPath.fovList[i];
if (point.positionModes == CameraPathPoint.PositionModes.Free)
{
Handles.DotCap(0, point.worldPosition, Quaternion.identity, 0.2f);
}
}
numberOfCPoints = _cameraPath.delayList.realNumberOfPoints;
for (int i = 0; i < numberOfCPoints; i++)
{
CameraPathPoint point = _cameraPath.delayList[i];
if (point.positionModes == CameraPathPoint.PositionModes.Free)
{
Handles.DotCap(0, point.worldPosition, Quaternion.identity, 0.2f);
}
}
numberOfCPoints = _cameraPath.orientationList.realNumberOfPoints;
for (int i = 0; i < numberOfCPoints; i++)
{
CameraPathPoint point = _cameraPath.orientationList[i];
if (point.positionModes == CameraPathPoint.PositionModes.Free)
{
Handles.DotCap(0, point.worldPosition, Quaternion.identity, 0.2f);
}
}
numberOfCPoints = _cameraPath.speedList.realNumberOfPoints;
for (int i = 0; i < numberOfCPoints; i++)
{
CameraPathPoint point = _cameraPath.speedList[i];
if (point.positionModes == CameraPathPoint.PositionModes.Free)
{
Handles.DotCap(0, point.worldPosition, Quaternion.identity, 0.2f);
}
}
numberOfCPoints = _cameraPath.tiltList.realNumberOfPoints;
for (int i = 0; i < numberOfCPoints; i++)
{
CameraPathPoint point = _cameraPath.tiltList[i];
if (point.positionModes == CameraPathPoint.PositionModes.Free)
{
Handles.DotCap(0, point.worldPosition, Quaternion.identity, 0.2f);
}
}
//draw path outline
Camera sceneCamera = Camera.current;
int numberOfPoints = _cameraPath.numberOfPoints;
Handles.color = _cameraPath.selectedPathColour;
float pointPercentage = 1.0f / (numberOfPoints - 1);
for (int i = 0; i < numberOfPoints - 1; i++)
{
CameraPathControlPoint pointA = _cameraPath.GetPoint(i);
CameraPathControlPoint pointB = _cameraPath.GetPoint(i + 1);
float dotPA = Vector3.Dot(sceneCamera.transform.forward, pointA.worldPosition - sceneCamera.transform.position);
float dotPB = Vector3.Dot(sceneCamera.transform.forward, pointB.worldPosition - sceneCamera.transform.position);
if (dotPA < 0 && dotPB < 0)//points are both behind camera - don't render
{
continue;
}
float pointAPercentage = pointPercentage * i;
float pointBPercentage = pointPercentage * (i + 1);
float arcPercentage = pointBPercentage - pointAPercentage;
Vector3 arcCentre = (pointA.worldPosition + pointB.worldPosition) * 0.5f;
float arcLength = _cameraPath.StoredArcLength(_cameraPath.GetCurveIndex(pointA.index));
float arcDistance = Vector3.Distance(sceneCamera.transform.position, arcCentre);
int arcPoints = Mathf.Max(Mathf.RoundToInt(arcLength * (40 / Mathf.Max(arcDistance, 20))), 10);
float arcTime = 1.0f / arcPoints;
float endLoop = 1.0f - arcTime;
Vector3 lastPoint = Vector3.zero;
for (float p = 0; p < endLoop; p += arcTime)
{
float p2 = p + arcTime;
float pathPercentageA = pointAPercentage + arcPercentage * p;
float pathPercentageB = pointAPercentage + arcPercentage * p2;
Vector3 lineStart = _cameraPath.GetPathPosition(pathPercentageA, true);
Vector3 lineEnd = _cameraPath.GetPathPosition(pathPercentageB, true);
Handles.DrawLine(lineStart, lineEnd);
lastPoint = lineEnd;
}
Handles.DrawLine(lastPoint, _cameraPath.GetPathPosition(pointBPercentage, true));
}
switch (_pointMode)
{
case CameraPath.PointModes.Transform:
SceneGUIPointBased();
break;
case CameraPath.PointModes.ControlPoints:
SceneGUIPointBased();
break;
case CameraPath.PointModes.Orientations:
SceneGUIOrientationBased();
break;
case CameraPath.PointModes.FOV:
SceneGUIFOVBased();
break;
case CameraPath.PointModes.Events:
SceneGUIEventBased();
break;
case CameraPath.PointModes.Speed:
SceneGUISpeedBased();
break;
case CameraPath.PointModes.Tilt:
SceneGUITiltBased();
break;
case CameraPath.PointModes.Delay:
SceneGUIDelayBased();
break;
case CameraPath.PointModes.Ease:
SceneGUIEaseBased();
break;
case CameraPath.PointModes.AddPathPoints:
AddPathPoints();
break;
case CameraPath.PointModes.RemovePathPoints:
RemovePathPoints();
break;
case CameraPath.PointModes.AddOrientations:
AddCPathPoints();
break;
case CameraPath.PointModes.AddFovs:
AddCPathPoints();
break;
case CameraPath.PointModes.AddTilts:
AddCPathPoints();
break;
case CameraPath.PointModes.AddEvents:
AddCPathPoints();
break;
case CameraPath.PointModes.AddSpeeds:
AddCPathPoints();
break;
case CameraPath.PointModes.AddDelays:
AddCPathPoints();
break;
case CameraPath.PointModes.RemoveOrientations:
RemoveCPathPoints();
break;
case CameraPath.PointModes.RemoveTilts:
RemoveCPathPoints();
break;
case CameraPath.PointModes.RemoveFovs:
RemoveCPathPoints();
break;
case CameraPath.PointModes.RemoveEvents:
RemoveCPathPoints();
break;
case CameraPath.PointModes.RemoveSpeeds:
RemoveCPathPoints();
break;
case CameraPath.PointModes.RemoveDelays:
RemoveCPathPoints();
break;
}
if (Event.current.type == EventType.ValidateCommand)
{
switch (Event.current.commandName)
{
case "UndoRedoPerformed":
GUI.changed = true;
break;
}
}
}
