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