/// <summary>Get the location at spline point</summary> public FVector GetLocationAtSplinePoint(int PointIndex, ESplineCoordinateSpace CoordinateSpace) { CheckIsValid(); FVector ___ret = GetLocationAtSplinePoint(_this.Get(), PointIndex, (int)CoordinateSpace); return(___ret); }
/// <summary>Get the transform at spline point</summary> public FTransform GetTransformAtSplinePoint(int PointIndex, ESplineCoordinateSpace CoordinateSpace, bool bUseScale = false) { CheckIsValid(); FTransform ___ret = GetTransformAtSplinePoint(_this.Get(), PointIndex, (int)CoordinateSpace, bUseScale?1:0); return(___ret); }
/// <summary>Get the amount of roll at spline point, in degrees</summary> public float GetRollAtSplinePoint(int PointIndex, ESplineCoordinateSpace CoordinateSpace) { CheckIsValid(); float ___ret = GetRollAtSplinePoint(_this.Get(), PointIndex, (int)CoordinateSpace); return(___ret); }
/// <summary>Given a location, in world space, return the spline's roll closest to the location, in degrees.</summary> public float FindRollClosestToWorldLocation(FVector WorldLocation, ESplineCoordinateSpace CoordinateSpace) { CheckIsValid(); float ___ret = FindRollClosestToWorldLocation(_this.Get(), ref WorldLocation, (int)CoordinateSpace); return(___ret); }
public void AddSplinePointAtIndex(Vector3 Position, int Index, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline = true) { Vector3 TransformedPosition = (CoordinateSpace == ESplineCoordinateSpace.World) ? transform.InverseTransformPoint(Position) : Position; int NumPoints = SplineCurves.Position.Points.Count; if (Index >= 0 && Index <= NumPoints) { float InKey = (Index == 0) ? 0.0f : SplineCurves.Position.Points[Index - 1].InVal + 1.0f; SplineCurves.Position.Points.Insert(Index, new FInterpCurveVectorPoint(InKey, TransformedPosition, Vector3.zero, Vector3.zero, ESplinePointType.Curve)); SplineCurves.Rotation.Points.Insert(Index, new FInterpCurveQuaternionPoint(InKey, Quaternion.identity, Quaternion.identity, Quaternion.identity, ESplinePointType.Curve)); SplineCurves.Scale.Points.Insert(Index, new FInterpCurveVectorPoint(InKey, Vector3.one, Vector3.zero, Vector3.zero, ESplinePointType.Curve)); NumPoints++; // Adjust subsequent points' input keys to make room for the value just added for (int I = Index + 1; I < NumPoints; ++I) { SplineCurves.Position.Points[I].InVal += 1.0f; SplineCurves.Rotation.Points[I].InVal += 1.0f; SplineCurves.Scale.Points[I].InVal += 1.0f; } if (bLoopPositionOverride) { LoopPosition += 1.0f; } } }
/// <summary>Given a distance along the length of this spline, return the spline's roll there, in degrees.</summary> public float GetRollAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) { CheckIsValid(); float ___ret = GetRollAtDistanceAlongSpline(_this.Get(), Distance, (int)CoordinateSpace); return(___ret); }
/// <summary>Given a distance along the length of this spline, return the point in space where this puts you</summary> public FVector GetLocationAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace) { CheckIsValid(); FVector ___ret = GetLocationAtDistanceAlongSpline(_this.Get(), Distance, (int)CoordinateSpace); return(___ret); }
/// <summary>Given a distance along the length of this spline, return an FTransform corresponding to that point on the spline.</summary> public FTransform GetTransformAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace, bool bUseScale = false) { CheckIsValid(); FTransform ___ret = GetTransformAtDistanceAlongSpline(_this.Get(), Distance, (int)CoordinateSpace, bUseScale?1:0); return(___ret); }
/// <summary>Given a time from 0 to the spline duration, return the point in space where this puts you</summary> public FVector GetLocationAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity = false) { CheckIsValid(); FVector ___ret = GetLocationAtTime(_this.Get(), Time, (int)CoordinateSpace, bUseConstantVelocity?1:0); return(___ret); }
/// <summary>Given a time from 0 to the spline duration, return the spline's transform at the corresponding position.</summary> public FTransform GetTransformAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity = false, bool bUseScale = false) { CheckIsValid(); FTransform ___ret = GetTransformAtTime(_this.Get(), Time, (int)CoordinateSpace, bUseConstantVelocity?1:0, bUseScale?1:0); return(___ret); }
/// <summary>Given a location, in world spcae, return a unit direction vector of the spline tangent closest to the location.</summary> public FVector FindDirectionClosestToWorldLocation(FVector WorldLocation, ESplineCoordinateSpace CoordinateSpace) { CheckIsValid(); FVector ___ret = FindDirectionClosestToWorldLocation(_this.Get(), ref WorldLocation, (int)CoordinateSpace); return(___ret); }
/// <summary>Gets the default up vector used by this spline</summary> public FVector GetDefaultUpVector(ESplineCoordinateSpace CoordinateSpace) { CheckIsValid(); FVector ___ret = GetDefaultUpVector(_this.Get(), (int)CoordinateSpace); return(___ret); }
/// <summary>Given a location, in world space, return an FTransform closest to that location.</summary> public FTransform FindTransformClosestToWorldLocation(FVector WorldLocation, ESplineCoordinateSpace CoordinateSpace, bool bUseScale = false) { CheckIsValid(); FTransform ___ret = FindTransformClosestToWorldLocation(_this.Get(), ref WorldLocation, (int)CoordinateSpace, bUseScale?1:0); return(___ret); }
/// <summary>Given a time from 0 to the spline duration, return the spline's roll there, in degrees.</summary> public float GetRollAtTime(float Time, ESplineCoordinateSpace CoordinateSpace, bool bUseConstantVelocity = false) { CheckIsValid(); float ___ret = GetRollAtTime(_this.Get(), Time, (int)CoordinateSpace, bUseConstantVelocity?1:0); return(___ret); }
/// <summary> /// 取样线关键点的 位置 /// </summary> public Vector3 GetLocationAtSplinePoint(int PointIndex, ESplineCoordinateSpace CoordinateSpace) { int NumPoints = SplineCurves.Position.Points.Count; int ClampedIndex = (bClosedLoop && PointIndex >= NumPoints) ? 0 : Mathf.Clamp(PointIndex, 0, NumPoints - 1); Vector3 Location = SplineCurves.Position.Points[ClampedIndex].OutVal; return((CoordinateSpace == ESplineCoordinateSpace.World) ? transform.TransformPoint(Location) : Location); }
/// <summary> /// 取样线关键点的 进入点切线值 /// </summary> public Vector3 GetArriveTangentAtSplinePoint(int PointIndex, ESplineCoordinateSpace CoordinateSpace) { int NumPoints = SplineCurves.Position.Points.Count; int ClampedIndex = (bClosedLoop && PointIndex >= NumPoints) ? 0 : Mathf.Clamp(PointIndex, 0, NumPoints - 1); Vector3 Direction = SplineCurves.Position.Points[ClampedIndex].ArriveTangent; return((CoordinateSpace == ESplineCoordinateSpace.World) ? transform.TransformVector(Direction) : Direction); }
////////////////////////////////////////////////////////////////////////////////////////////////////// #region 沿样线 键值 的操作 /// <summary> /// 在给定输入键值处沿样线获取位置 /// </summary> /// <param name="InKey">键值</param> /// <param name="CoordinateSpace">返回世界坐标向量还是局部向量</param> public Vector3 GetLocationAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) { Vector3 Location = SplineCurves.Position.Eval(InKey, Vector3.zero); if (CoordinateSpace == ESplineCoordinateSpace.World) { Location = transform.TransformPoint(Location);//ComponentToWorld.TransformPosition(Location); } return(Location); }
/// <summary> /// 在给定输入键值处沿样线获取切线角度 /// </summary> /// <param name="InKey">键值</param> /// <param name="CoordinateSpace">返回世界坐标向量还是局部向量</param> public Quaternion GetTangentAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) { Vector3 Tangent = SplineCurves.Position.EvalDerivative(InKey, Vector3.zero); if (CoordinateSpace == ESplineCoordinateSpace.World) { Tangent = transform.TransformVector(Tangent);//ComponentToWorld.TransformVector(Tangent); } return(Tangent.ToQuaternion());//Vector3ToQuat(Tangent); }
/// <summary> /// 设置样线关键点的旋转值 /// </summary> public void SetQuaternionAtSplineInputKey(int PointIndex, Quaternion Quat, ESplineCoordinateSpace CoordinateSpace) { int NumPoints = SplineCurves.Position.Points.Count; int ClampedIndex = (bClosedLoop && PointIndex >= NumPoints) ? 0 : Mathf.Clamp(PointIndex, 0, NumPoints - 1); if ((ClampedIndex >= 0) && (ClampedIndex < NumPoints)) { Quaternion Quatern = (CoordinateSpace == ESplineCoordinateSpace.World) ? transform.localRotation * Quat : Quat; SplineCurves.Rotation.Points[ClampedIndex].OutVal = Quatern; } }
/// <summary> /// 在给定输入键值处沿样线获取 右方向向量值 /// </summary> Vector3 GetRightVectorAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) { Quaternion Quat = GetQuaternionAtSplineInputKey(InKey, ESplineCoordinateSpace.Local); Vector3 RightVector = Quat.RotateVector(Vector3.right);//RotateVector(Quat, Vector3.right); if (CoordinateSpace == ESplineCoordinateSpace.World) { RightVector = transform.TransformVector(RightVector); } return(RightVector); }
/// <summary> /// 在给定输入键值处沿样线获取旋转角度 /// </summary> public Quaternion GetQuaternionAtSplineInputKey(float InKey, ESplineCoordinateSpace CoordinateSpace) { Quaternion Quat = SplineCurves.Rotation.Eval(InKey, Quaternion.identity); Vector3 Direction = SplineCurves.Position.EvalDerivative(InKey, Vector3.zero); //.GetSafeNormal(); Vector3 UpVector = Quat.RotateVector(DefaultUpVector); //RotateVector(Quat, DefaultUpVector); Quaternion Rot = (MathfExtensions.MakeFromXZ(Direction, UpVector)).ToQuat(); if (CoordinateSpace == ESplineCoordinateSpace.World) { Rot = transform.rotation * Rot; } return(Rot); }
/// <summary> /// 设置关键点的坐标 /// </summary> public void SetLocationAtSplinePoint(int PointIndex, Vector3 InLocation, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline = true) { int NumPoints = SplineCurves.Position.Points.Count; if ((PointIndex >= 0) && (PointIndex < NumPoints)) { Vector3 TransformedLocation = (CoordinateSpace == ESplineCoordinateSpace.World) ? transform.InverseTransformPoint(InLocation) : InLocation; SplineCurves.Position.Points[PointIndex].OutVal = TransformedLocation; if (bUpdateSpline) { UpdateSpline(); } } }
protected void UseNode(float _fDistance, ESplineCoordinateSpace _eCoorSpace = ESplineCoordinateSpace.World) { Vector3 pointLoc = Spline.GetLocationAtDistanceAlongSpline(_fDistance, _eCoorSpace); Quaternion pointTang = Spline.GetTangentAtDistanceAlongSpline(_fDistance, _eCoorSpace); Transform tmpTrans = null; if (!GetUnuseObject(out tmpTrans)) { return; } if (_eCoorSpace == ESplineCoordinateSpace.Local) { tmpTrans.localPosition = pointLoc; tmpTrans.localRotation = pointTang; } }
public void AddSplinePoint(Vector3 Position, ESplineCoordinateSpace CoordinateSpace, bool bUpdateSpline = true) { Vector3 TransformedPosition = (CoordinateSpace == ESplineCoordinateSpace.World) ? transform.InverseTransformPoint(Position) : Position; // Add the spline point at the end of the array, adding 1.0 to the current last input key. // This continues the former behavior in which spline points had to be separated by an interval of 1.0. float InKey = SplineCurves.Position.Points.Count > 0 ? SplineCurves.Position.Points.Last().InVal + 1.0f : 0.0f; SplineCurves.Position.Points.Add(new FInterpCurveVectorPoint(InKey, TransformedPosition, Vector3.zero, Vector3.zero, ESplinePointType.Curve)); SplineCurves.Rotation.Points.Add(new FInterpCurveQuaternionPoint(InKey, Quaternion.identity, Quaternion.identity, Quaternion.identity, ESplinePointType.Curve)); SplineCurves.Scale.Points.Add(new FInterpCurveVectorPoint(InKey, Vector3.one, Vector3.zero, Vector3.zero, ESplinePointType.Curve)); if (bLoopPositionOverride) { LoopPosition += 1.0f; } if (bUpdateSpline) { UpdateSpline(); } }
/// <summary>Sets the default up vector used by this spline</summary> public extern void SetDefaultUpVector(FVector UpVector, ESplineCoordinateSpace CoordinateSpace);
/// <summary>Gets the default up vector used by this spline</summary> public extern FVector GetDefaultUpVector(ESplineCoordinateSpace CoordinateSpace);
/// <summary>Given a distance along the length of this spline, return the point in space where this puts you</summary> public extern FVector GetLocationAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace);
/// <summary>Given a distance along the length of this spline, return the tangent vector of the spline there.</summary> public extern FVector GetTangentAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace);
/// <summary>Given a distance along the length of this spline, return a rotation corresponding to the spline's rotation there.</summary> public extern FRotator GetRotationAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace);
/// <summary>Given a distance along the length of this spline, return a unit direction vector corresponding to the spline's right vector there.</summary> public extern FVector GetRightVectorAtDistanceAlongSpline(float Distance, ESplineCoordinateSpace CoordinateSpace);