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