/// <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);
