public override void FromXML(XmlNodeList nodes)
{
Clear();
foreach (XmlNode node in nodes)
{
CameraPathOrientation newCameraPathPoint = gameObject.AddComponent <CameraPathOrientation>();//CreateInstance<CameraPathOrientation>();
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);
}
}
private Quaternion CubicInterpolation(float percentage)
{
int index = GetLastPointIndex(percentage);
CameraPathOrientation pointP = (CameraPathOrientation)GetPoint(index);
CameraPathOrientation pointQ = (CameraPathOrientation)GetPoint(index + 1);
CameraPathOrientation pointA = (CameraPathOrientation)GetPoint(index - 1);
CameraPathOrientation pointB = (CameraPathOrientation)GetPoint(index + 2);
float startPercentage = pointP.percent;
float endPercentage = pointQ.percent;
if (startPercentage > endPercentage)
{
endPercentage += 1;
}
float curveLength = endPercentage - startPercentage;
float curvePercentage = percentage - startPercentage;
float ct = curvePercentage / curveLength;
Quaternion returnQ = CPMath.CalculateCubic(pointP.rotation, pointA.rotation, pointB.rotation, pointQ.rotation, ct);
if (float.IsNaN(returnQ.x))
{
Debug.Log(percentage + " " + pointP.fullName + " " + pointQ.fullName + " " + pointA.fullName + " " + pointB.fullName);
}
return(returnQ);
}
//public override void FromXML(XmlNodeList nodes)
//{
// Clear();
// foreach (XmlNode node in nodes)
// {
// CameraPathOrientation newCameraPathPoint = gameObject.AddComponent<CameraPathOrientation>();//CreateInstance<CameraPathOrientation>();
// 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 override void FromXML(XMLNodeList nodes)
{
Clear();
foreach (XMLNode node in nodes)
{
CameraPathOrientation newCameraPathPoint = gameObject.AddComponent <CameraPathOrientation>();//CreateInstance<CameraPathOrientation>();
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:
string strPoint = node.GetValue("point>0>_text");
CameraPathControlPoint point = cameraPath[int.Parse(strPoint)];
AddPoint(newCameraPathPoint, point);
break;
}
newCameraPathPoint.FromXML(node, cameraPath);
}
}
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 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 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 Quaternion GetOrientation(float percentage)
{
if (base.realNumberOfPoints < 2)
{
if (base.realNumberOfPoints == 1)
{
return(this[0].rotation);
}
return(Quaternion.get_identity());
}
else
{
if (float.IsNaN(percentage))
{
percentage = 0f;
}
percentage = Mathf.Clamp(percentage, 0f, 1f);
Quaternion result = Quaternion.get_identity();
switch (this.interpolation)
{
case CameraPathOrientationList.Interpolation.None:
{
CameraPathOrientation cameraPathOrientation = (CameraPathOrientation)base.GetPoint(base.GetNextPointIndex(percentage));
result = cameraPathOrientation.rotation;
break;
}
case CameraPathOrientationList.Interpolation.Linear:
result = this.LinearInterpolation(percentage);
break;
case CameraPathOrientationList.Interpolation.SmoothStep:
result = this.SmootStepInterpolation(percentage);
break;
case CameraPathOrientationList.Interpolation.Hermite:
result = this.CubicInterpolation(percentage);
break;
case CameraPathOrientationList.Interpolation.Cubic:
result = this.CubicInterpolation(percentage);
break;
default:
result = Quaternion.LookRotation(Vector3.get_forward());
break;
}
if (float.IsNaN(result.x))
{
return(Quaternion.get_identity());
}
return(result);
}
}
public Quaternion GetOrientation(float percentage)
{
if (realNumberOfPoints < 2)
{
if (realNumberOfPoints == 1)
{
return((this[0]).rotation);
}
return(Quaternion.identity);
}
if (float.IsNaN(percentage))
{
percentage = 0;
}
percentage = Mathf.Clamp(percentage, 0.0f, 1.0f);
Quaternion returnQ = Quaternion.identity;
switch (interpolation)
{
case Interpolation.Cubic:
returnQ = CubicInterpolation(percentage);
break;
case Interpolation.Hermite:
returnQ = CubicInterpolation(percentage);
break;
case Interpolation.SmoothStep:
returnQ = SmootStepInterpolation(percentage);
break;
case Interpolation.Linear:
returnQ = LinearInterpolation(percentage);
break;
case Interpolation.None:
CameraPathOrientation point = (CameraPathOrientation)GetPoint(GetNextPointIndex(percentage));
returnQ = point.rotation;
break;
default:
returnQ = Quaternion.LookRotation(Vector3.forward);
break;
}
if (float.IsNaN(returnQ.x))
{
return(Quaternion.identity);
}
return(returnQ);
}
protected override void RecalculatePoints()
{
base.RecalculatePoints();
for (int i = 0; i < base.realNumberOfPoints; i++)
{
CameraPathOrientation cameraPathOrientation = this[i];
if (cameraPathOrientation.lookAt != null)
{
cameraPathOrientation.rotation = Quaternion.LookRotation(cameraPathOrientation.lookAt.get_transform().get_position() - cameraPathOrientation.worldPosition);
}
}
}
protected override void RecalculatePoints()
{
base.RecalculatePoints();
for (int i = 0; i < realNumberOfPoints; i++)
{
CameraPathOrientation point = this[i];
if (point.lookAt != null)
{
point.rotation = Quaternion.LookRotation(point.lookAt.transform.position - point.worldPosition);
}
}
}
public void AddOrientation(CameraPathControlPoint atPoint)
{
CameraPathOrientation cameraPathOrientation = base.get_gameObject().AddComponent <CameraPathOrientation>();
if (atPoint.forwardControlPoint != Vector3.get_zero())
{
cameraPathOrientation.rotation = Quaternion.LookRotation(atPoint.forwardControlPoint);
}
else
{
cameraPathOrientation.rotation = Quaternion.LookRotation(this.cameraPath.GetPathDirection(atPoint.percentage));
}
cameraPathOrientation.set_hideFlags(2);
base.AddPoint(cameraPathOrientation, atPoint);
this.RecalculatePoints();
}
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;
}
private Quaternion SmootStepInterpolation(float percentage)
{
int lastPointIndex = base.GetLastPointIndex(percentage);
CameraPathOrientation cameraPathOrientation = (CameraPathOrientation)base.GetPoint(lastPointIndex);
CameraPathOrientation cameraPathOrientation2 = (CameraPathOrientation)base.GetPoint(lastPointIndex + 1);
float percent = cameraPathOrientation.percent;
float num = cameraPathOrientation2.percent;
if (percent > num)
{
num += 1f;
}
float num2 = num - percent;
float num3 = percentage - percent;
float val = num3 / num2;
return(Quaternion.Lerp(cameraPathOrientation.rotation, cameraPathOrientation2.rotation, CPMath.SmoothStep(val)));
}
private Quaternion LinearInterpolation(float percentage)
{
int lastPointIndex = base.GetLastPointIndex(percentage);
CameraPathOrientation cameraPathOrientation = (CameraPathOrientation)base.GetPoint(lastPointIndex);
CameraPathOrientation cameraPathOrientation2 = (CameraPathOrientation)base.GetPoint(lastPointIndex + 1);
float percent = cameraPathOrientation.percent;
float num = cameraPathOrientation2.percent;
if (percent > num)
{
num += 1f;
}
float num2 = num - percent;
float num3 = percentage - percent;
float num4 = num3 / num2;
return(Quaternion.Lerp(cameraPathOrientation.rotation, cameraPathOrientation2.rotation, num4));
}
private Quaternion LinearInterpolation(float percentage)
{
int index = GetLastPointIndex(percentage);
CameraPathOrientation pointP = (CameraPathOrientation)GetPoint(index);
CameraPathOrientation pointQ = (CameraPathOrientation)GetPoint(index + 1);
float startPercentage = pointP.percent;
float endPercentage = pointQ.percent;
if (startPercentage > endPercentage)
{
endPercentage += 1;
}
float curveLength = endPercentage - startPercentage;
float curvePercentage = percentage - startPercentage;
float ct = curvePercentage / curveLength;
return(Quaternion.Lerp(pointP.rotation, pointQ.rotation, ct));
}
private Quaternion CubicInterpolation(float percentage)
{
int lastPointIndex = base.GetLastPointIndex(percentage);
CameraPathOrientation cameraPathOrientation = (CameraPathOrientation)base.GetPoint(lastPointIndex);
CameraPathOrientation cameraPathOrientation2 = (CameraPathOrientation)base.GetPoint(lastPointIndex + 1);
CameraPathOrientation cameraPathOrientation3 = (CameraPathOrientation)base.GetPoint(lastPointIndex - 1);
CameraPathOrientation cameraPathOrientation4 = (CameraPathOrientation)base.GetPoint(lastPointIndex + 2);
float percent = cameraPathOrientation.percent;
float num = cameraPathOrientation2.percent;
if (percent > num)
{
num += 1f;
}
float num2 = num - percent;
float num3 = percentage - percent;
float t = num3 / num2;
Quaternion result = CPMath.CalculateCubic(cameraPathOrientation.rotation, cameraPathOrientation3.rotation, cameraPathOrientation4.rotation, cameraPathOrientation2.rotation, t);
if (float.IsNaN(result.x))
{
Debug.Log(string.Concat(new object[]
{
percentage,
" ",
cameraPathOrientation.fullName,
" ",
cameraPathOrientation2.fullName,
" ",
cameraPathOrientation3.fullName,
" ",
cameraPathOrientation4.fullName
}));
result = cameraPathOrientation.rotation;
}
return(result);
}
private 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;
}
}
private static void SceneGUIOrientationBased()
{
DisplayAtPoint();
CameraPathOrientationList orientationList = _cameraPath.orientationList;
Camera sceneCamera = Camera.current;
int orientationCount = orientationList.realNumberOfPoints;
for (int i = 0; i < orientationCount; i++)
{
CameraPathOrientation orientation = orientationList[i];
if (_cameraPath.enableUndo)
{
Undo.RecordObject(orientation, "Modifying Orientation Point");
}
if (Vector3.Dot(sceneCamera.transform.forward, orientation.worldPosition - sceneCamera.transform.position) < 0)
{
continue;
}
string orientationLabel = orientation.displayName;
orientationLabel += "\nat percentage: " + orientation.percent.ToString("F3");
switch (orientation.positionModes)
{
case CameraPathPoint.PositionModes.FixedToPoint:
orientationLabel += "\nat point: " + orientation.point.displayName;
break;
}
Handles.Label(orientation.worldPosition, orientationLabel);
float pointHandleSize = HandleUtility.GetHandleSize(orientation.worldPosition) * HANDLE_SCALE;
Handles.color = (i == selectedPointIndex) ? _cameraPath.selectedPointColour : _cameraPath.unselectedPointColour;
Handles.ArrowCap(0, orientation.worldPosition, orientation.rotation, pointHandleSize * 4);
if (Handles.Button(orientation.worldPosition, Quaternion.identity, pointHandleSize, pointHandleSize, Handles.DotCap))
{
ChangeSelectedPointIndex(i);
GUI.changed = true;
}
if (i == selectedPointIndex)
{
Quaternion currentRotation = orientation.rotation;
currentRotation = Handles.DoRotationHandle(currentRotation, orientation.worldPosition);
if (currentRotation != orientation.rotation)
{
orientation.rotation = currentRotation;
}
CPPSlider(orientation);
}
}
if (_cameraPath.showOrientationIndicators)//draw orientation indicators
{
Handles.color = _cameraPath.orientationIndicatorColours;
float indicatorLength = _cameraPath.orientationIndicatorUnitLength / _cameraPath.pathLength;
for (float i = 0; i < 1; i += indicatorLength)
{
Vector3 indicatorPosition = _cameraPath.GetPathPosition(i);
Quaternion inicatorRotation = _cameraPath.GetPathRotation(i, false);
float indicatorHandleSize = HandleUtility.GetHandleSize(indicatorPosition) * HANDLE_SCALE * 4;
Handles.ArrowCap(0, indicatorPosition, inicatorRotation, indicatorHandleSize);
}
}
}
public void fromLua(CameraPathOrientation pathOrientation, int index, float percent, float curvePercentage, Quaternion quater)
{
pathOrientation.index = index;
pathOrientation.percent = percent;
pathOrientation.curvePercentage = curvePercentage;
pathOrientation.rotation = quater;
}
public void RemovePoint(CameraPathOrientation orientation)
{
base.RemovePoint(orientation);
this.RecalculatePoints();
}
public static void AlignCamera()
{
GameObject selected = Selection.activeGameObject;
CameraPath camPath = selected.GetComponent <CameraPath>();
CameraPathAnimator animator = selected.GetComponent <CameraPathAnimator>();
Undo.RecordObject(camPath, "Align View to Camera Path Point");
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];
GameObject tempPos = new GameObject("temp");
tempPos.transform.position = point.worldPosition;
tempPos.transform.rotation = point.rotation;
SceneView.currentDrawingSceneView.AlignViewToObject(tempPos.transform);
DestroyImmediate(tempPos);
}
if (camPath.pointMode == CameraPath.PointModes.Transform || camPath.pointMode == CameraPath.PointModes.ControlPoints)
{
int selectedPoint = camPath.selectedPoint;
CameraPathControlPoint cPoint = camPath[selectedPoint];
CameraPathOrientation point = (CameraPathOrientation)camPath.orientationList.GetPoint(cPoint);
GameObject tempPos = new GameObject("temp");
tempPos.transform.position = cPoint.worldPosition;
if (Camera.current != null)
{
Camera.current.transform.position = cPoint.worldPosition;
}
if (point != null)
{
tempPos.transform.rotation = point.rotation;
}
else
{
tempPos.transform.rotation = Quaternion.LookRotation(camPath.GetPathDirection(cPoint.percentage));
}
SceneView.currentDrawingSceneView.AlignViewToObject(tempPos.transform);
DestroyImmediate(tempPos);
}
break;
default:
if (camPath.pointMode == CameraPath.PointModes.Transform || camPath.pointMode == CameraPath.PointModes.ControlPoints)
{
int selectedPoint = camPath.selectedPoint;
CameraPathControlPoint point = camPath[selectedPoint];
GameObject tempPos = new GameObject("temp");
tempPos.transform.position = point.worldPosition;
tempPos.transform.rotation = Quaternion.LookRotation(point.forwardControlPoint.normalized);
SceneView.currentDrawingSceneView.AlignViewToObject(tempPos.transform);
DestroyImmediate(tempPos);
}
break;
}
}
}
public void RemovePoint(CameraPathOrientation orientation)
{
base.RemovePoint(orientation);
RecalculatePoints();
}
