/**
* Get a normalized copy of this quaternion.
* If it is too small, returns an identity quaternion.
*
* @param Tolerance Minimum squared length of quaternion for normalization.
*/
public FQuat GetNormalized(float Tolerance = Const.SMALL_NUMBER)
{
FQuat Result = this;
Result.Normalize(Tolerance);
return(Result);
}
public FQuat(FQuat Q)
{
X = Q.X;
Y = Q.Y;
Z = Q.Z;
W = Q.W;
}
/**
* @note Exp should really only be used after Log.
* Assumes a quaternion with W=0 and V=theta*v (where |v| = 1).
* Exp(q) = (sin(theta)*v, cos(theta))
*/
public FQuat Exp()
{
float Angle = (float)FMath.Sqrt(X * X + Y * Y + Z * Z);
float SinAngle = (float)FMath.Sin(Angle);
FQuat Result = new FQuat();
Result.W = (float)FMath.Cos(Angle);
if (FMath.Abs(SinAngle) >= Const.SMALL_NUMBER)
{
float Scale = SinAngle / Angle;
Result.X = Scale * X;
Result.Y = Scale * Y;
Result.Z = Scale * Z;
}
else
{
Result.X = X;
Result.Y = Y;
Result.Z = Z;
}
return(Result);
}
/**
* Checks whether another Quaternion is equal to this, within specified tolerance.
*
* @param Q The other Quaternion.
* @param Tolerance Error Tolerance.
* @return true if two Quaternion are equal, within specified tolerance, otherwise false.
*/
public override bool Equals(object Obj)
{
FQuat Q = (FQuat)Obj;
float Tolerance = Const.KINDA_SMALL_NUMBER;
return((FMath.Abs(X - Q.X) <= Tolerance && FMath.Abs(Y - Q.Y) <= Tolerance && FMath.Abs(Z - Q.Z) <= Tolerance && FMath.Abs(W - Q.W) <= Tolerance) ||
(FMath.Abs(X + Q.X) <= Tolerance && FMath.Abs(Y + Q.Y) <= Tolerance && FMath.Abs(Z + Q.Z) <= Tolerance && FMath.Abs(W + Q.W) <= Tolerance));
}
/**
* Sets the components
* @param InRotation The new value for the Rotation component
* @param InTranslation The new value for the Translation component
* @param InScale3D The new value for the Scale3D component
*/
public void SetComponents(FQuat InRotation, FVector InTranslation, FVector InScale3D)
{
Rotation = InRotation;
Translation = InTranslation;
Scale3D = InScale3D;
DiagnosticCheckNaN_All();
}
/**
* Convert this Transform to inverse.
*/
public FTransform Inverse()
{
FQuat InvRotation = Rotation.Inverse();
FVector InvScale3D = Scale3D.Reciprocal();
FVector InvTranslation = InvRotation * (InvScale3D * -Translation);
return(new FTransform(InvRotation, InvTranslation, InvScale3D));
}
/**
* Enforce that the delta between this Quaternion and another one represents
* the shortest possible rotation angle
*/
public void EnforceShortestArcWith(FQuat OtherQuat)
{
float DotResult = (OtherQuat | this);
float Bias = DotResult > 0 ? 1.0f : -1.0f;
X *= Bias;
Y *= Bias;
Z *= Bias;
W *= Bias;
}
public void SetFromMatrix(FMatrix InMatrix)
{
FMatrix M = InMatrix;
// Get the 3D scale from the matrix
Scale3D = M.ExtractScaling();
// If there is negative scaling going on, we handle that here
if (InMatrix.Determinant() < 0.0f)
{
// Assume it is along X and modify transform accordingly.
// It doesn't actually matter which axis we choose, the 'appearance' will be the same
Scale3D.X *= -1.0f;
M.SetAxis(0, -M.GetScaledAxis(EAxis.X));
}
Rotation = new FQuat(M);
Translation = InMatrix.GetOrigin();
// Normalize rotation
Rotation.Normalize();
}
/// <summary> /// <para>Inverse transform a rotation. </para> /// <para>For example if this is a LocalToWorld transform, InverseTransformRotation(Q) would transform Q from world to local space. </para> /// </summary> public FQuat InverseTransformRotation(FQuat q) => E_FTransform_InverseTransformRotation(this, q);
/// <summary> /// <para>Sets the components </para> /// <param name="InRotation">The new value for the Rotation component </param> /// <param name="InTranslation">The new value for the Translation component </param> /// <param name="InScale3D">The new value for the Scale3D component </param> /// </summary> public void SetComponents(FQuat inRotation, FVector inTranslation, FVector inScale3D) => E_FTransform_SetComponents(this, inRotation, inTranslation, inScale3D);
//[MethodImplAttribute(MethodImplOptions.InternalCall)] extern static FRotator Rotator(ref FQuat _this);
/// <summary> /// <para>Transform a rotation. </para> /// <para>For example if this is a LocalToWorld transform, TransformRotation(Q) would transform Q from local to world space. </para> /// </summary> public FQuat TransformRotation(FQuat q) => E_FTransform_TransformRotation(this, q);
/// <summary> /// <para>Sets the rotation component </para> /// <param name="NewRotation">The new value for the rotation component </param> /// </summary> public void SetRotation(FQuat newRotation) => E_FTransform_SetRotation(this, newRotation);
public FTransform(FRotator InRotation)
{
Rotation = new FQuat(InRotation);
Translation = FVector.ZeroVector;
Scale3D = new FVector(1.0f);
}
public FTransform(FQuat InRotation)
{
Rotation = InRotation;
Translation = FVector.ZeroVector;
Scale3D = new FVector(1.0f);
}
/// <summary>
/// <para>Constructor with all components initialized </para>
/// <param name="InRotation">The value to use for rotation component </param>
/// <param name="InTranslation">The value to use for the translation component </param>
/// <param name="InScale3D">The value to use for the scale component </param>
/// </summary>
public FTransform(FQuat inRotation, FVector inTranslation, FVector inScale3D) :
base(E_CreateStruct_FTransform_FQuat_FVector_FVector(inRotation, inTranslation, inScale3D), false)
{
}
public FDualQuat(FQuat inR, FQuat inD) :
base(E_CreateStruct_FDualQuat_FQuat_FQuat(inR, inD), false)
{
}
/// <summary>
/// <para>Copy constructor. </para>
/// <param name="Q">A FQuat object to use to create new quaternion from. </param>
/// </summary>
public FQuat(FQuat Q) :
base(E_CreateStruct_FQuat_FQuat(Q), false)
{
}
/// <summary> /// <para>Convert a FQuat to FRotator. Uses the cached conversion if possible, and updates it if there was no match. </para> /// </summary> public FRotator QuatToRotator(FQuat InQuat) => E_FRotationConversionCache_QuatToRotator(this, InQuat);
/**
* Sets the rotation component
* @param NewRotation The new value for the rotation component
*/
public void SetRotation(FQuat NewRotation)
{
Rotation = NewRotation;
DiagnosticCheckNaN_Rotate();
}
/**
* Concatenates another rotation to this transformation
* @param DeltaRotation The rotation to concatenate in the following fashion: Rotation = Rotation * DeltaRotation
*/
public void ConcatenateRotation(FQuat DeltaRotation)
{
Rotation = Rotation * DeltaRotation;
DiagnosticCheckNaN_Rotate();
}
public FTransform(FRotator InRotation, FVector InTranslation, FVector InScale3D)
{
Rotation = new FQuat(InRotation);
Translation = InTranslation;
Scale3D = InScale3D;
}
/**
* Transform a rotation matrix into a quaternion.
*
* @warning rotation part will need to be unit length for this to be right!
*/
public FQuat ToQuat()
{
FQuat Result = new FQuat(this);
return(Result);
}
//[MethodImplAttribute(MethodImplOptions.InternalCall)] extern static FQuat Multiply(ref FQuat _this, ref FQuat Other);
/// <summary>
/// <para>Constructor. </para>
/// <param name="Quat">Quaternion used to specify rotation. </param>
/// </summary>
public FRotator(FQuat quat) :
base(E_CreateStruct_FRotator_FQuat(quat), false)
{
}
public FTransform(FQuat InRotation, FVector InTranslation, FVector InScale3D)
{
Rotation = InRotation;
Translation = InTranslation;
Scale3D = InScale3D;
}
/// <summary> /// <para>Version of QuatToRotator when the Quat is known to already be normalized. Does *NOT* update the cache if there was no match. </para> /// </summary> public FRotator NormalizedQuatToRotator_ReadOnly(FQuat InNormalizedQuat) => E_FRotationConversionCache_NormalizedQuatToRotator_ReadOnly(this, InNormalizedQuat);
/// <summary> /// Matrix factory. Return an FMatrix so we don't have type conversion issues in expressions. /// </summary> public FMatrix Make(FQuat rot) => E_FRotationMatrix_Make_o1(this, rot);
/// <summary> /// <para>Convert a FQuat to FRotator. Uses the cached conversion if possible, but does *NOT* update the cache if there was no match. </para> /// </summary> public FRotator QuatToRotator_ReadOnly(FQuat InQuat) => E_FRotationConversionCache_QuatToRotator_ReadOnly(this, InQuat);
/// <summary> /// <para>Concatenates another rotation to this transformation </para> /// <param name="DeltaRotation">The rotation to concatenate in the following fashion: Rotation = Rotation * DeltaRotation </param> /// </summary> public void ConcatenateRotation(FQuat deltaRotation) => E_FTransform_ConcatenateRotation(this, deltaRotation);
