RRMathUtils.h

Go to the documentation of this file.

 
#pragma once
 
 
 
// Native
 
#include "math.h"
 
 
 
// UE
 
#include "Kismet/BlueprintFunctionLibrary.h"
 
#include "Kismet/KismetMathLibrary.h"
 
#include "Math/RandomStream.h"
 
//#include "Math/UnrealMath.h"
 
//#include "GenericPlatform/GenericPlatformMath.h"
 
 
 
#include "RRMathUtils.generated.h"
 
 
 
 
class RAPYUTASIMULATIONPLUGINS_API URRMathUtils : public UBlueprintFunctionLibrary
 
{
 
 
 
public:
 
    template<typename T>
 
    FORCEINLINE static void BitFlagsToStack(uint32 InBitFlags, TArray<T>& OutStack)
 
    {
 
        OutStack.Reset();
 
        while (InBitFlags != 0)
 
        {
 
            OutStack.Add((T)FBitSet::GetAndClearNextBit(InBitFlags));
 
        }
 
    }
 
 
 
    // VECTOR --
 
    // These are mostly for Velocity handling, which is inherently 3D FVector
 
    FORCEINLINE static bool IsVectorExceedingMaxMagnitude(const FVector& InVector, float InMaxMagnitude, bool b2D)
 
    {
 
        // Give 1% error tolerance, to account for numeric imprecision
 
        static constexpr float OVER_MAG_PERCENT = 1.01f;
 
        const float maxExtraMagnitude = OVER_MAG_PERCENT * FMath::Square(InMaxMagnitude);
 
        return (maxExtraMagnitude > 0.f) &&
 
               (b2D ? (InVector.SizeSquared2D() > maxExtraMagnitude) : (InVector.SizeSquared() > maxExtraMagnitude));
 
    }
 
 
 
    FORCEINLINE static void SetVectorClampedToMaxMagnitude(FVector& InVector, float InMaxMagnitude, bool b2D)
 
    {
 
        if (b2D)
 
        {
 
            InVector = InVector.GetClampedToMaxSize2D(InMaxMagnitude);
 
        }
 
        else
 
        {
 
            InVector = InVector.GetClampedToMaxSize(InMaxMagnitude);
 
        }
 
    }
 
 
 
    FORCEINLINE static bool ClampVectorToMaxMagnitude(FVector& InVector, float InMaxMagnitude, bool b2D)
 
    {
 
        if (IsVectorExceedingMaxMagnitude(InVector, InMaxMagnitude, b2D))
 
        {
 
            SetVectorClampedToMaxMagnitude(InVector, InMaxMagnitude, b2D);
 
            return true;
 
        }
 
        return false;
 
    }
 
 
 
    FORCEINLINE static void ClampRotatorToMaxAngles(FRotator& InRotator, const FRotator& InMaxAngles)
 
    {
 
        InRotator = FRotator(ClampAngle(InRotator.Pitch, InMaxAngles.Pitch),
 
                             ClampAngle(InRotator.Yaw, InMaxAngles.Yaw),
 
                             ClampAngle(InRotator.Roll, InMaxAngles.Roll));
 
    }
 
 
 
    template<typename T>
 
    FORCEINLINE static T ClampAngle(T InAngle, const T InMaxAngle)
 
    {
 
        // returns Angle in the range (-360,360)
 
        InAngle = FMath::Fmod(InAngle, 360.f);
 
        // Both FRotator::ClampAxis() and NormalizeAxis() could possible change the sign of InAngle so not used here
 
        return FMath::Clamp(InAngle, -InMaxAngle, InMaxAngle);
 
    }
 
 
 
    // RANDOM GENERATOR --
 
    static void InitializeRandomStream();
 
 
 
    template<typename T>
 
    FORCEINLINE static T GetRandomElement(const TArray<T>& InArray)
 
    {
 
        return (InArray.Num() > 0) ? InArray[GetRandomIntegerInRange(0, InArray.Num() - 1)] : T();
 
    }
 
 
 
 
    FORCEINLINE static float GetRandomBias()
 
    {
 
        return RandomStream.GetFraction();
 
    }
 
 
 
    FORCEINLINE static bool IsBiased(float InBias)
 
    {
 
        const float bias = GetRandomBias();
 
        return (bias > 0.f) && (bias <= InBias);
 
    }
 
 
 
    FORCEINLINE static bool IsBiased(float InMinBias, float InMaxBias)
 
    {
 
        return FMath::IsWithin(GetRandomBias(), InMinBias, InMaxBias);
 
    }
 
 
 
    FORCEINLINE static bool GetRandomBool()
 
    {
 
        return (GetRandomBias() >= 0.5f);
 
    }
 
 
 
    FORCEINLINE static float GetRandomFloatInRange(float InValueA, float InValueB)
 
    {
 
        return RandomStream.FRandRange(InValueA, InValueB);
 
    }
 
 
 
    FORCEINLINE static float GetRandomFloatInRange(const FVector2f& InValueRange)
 
    {
 
        return RandomStream.FRandRange(InValueRange.X, InValueRange.Y);
 
    }
 
 
 
    FORCEINLINE static int32 GetRandomIntegerInRange(int32 InValueA, int32 InValueB)
 
    {
 
        return RandomStream.RandRange(InValueA, InValueB);
 
    }
 
 
 
    FORCEINLINE static int32 GetRandomIntegerInRange(int32 InValueMax)
 
    {
 
        return RandomStream.RandRange(0, InValueMax);
 
    }
 
 
 
    FORCEINLINE static int32 GetRandomIntegerInRange(const FIntPoint& InValueRange)
 
    {
 
        return RandomStream.RandRange(InValueRange.X, InValueRange.Y);
 
    }
 
 
 
    FORCEINLINE static FVector GetRandomLocation(const FVector& InLocationA, const FVector& InLocationB)
 
    {
 
        return FVector(GetRandomFloatInRange(InLocationA.X, InLocationB.X),
 
                       GetRandomFloatInRange(InLocationA.Y, InLocationB.Y),
 
                       GetRandomFloatInRange(InLocationA.Z, InLocationB.Z));
 
    }
 
 
 
    FORCEINLINE static FQuat GetRandomOrientation()
 
    {
 
        const float u1 = GetRandomBias();
 
        const float u2 = GetRandomFloatInRange(0.f, UE_TWO_PI);
 
        const float u3 = GetRandomFloatInRange(0.f, UE_TWO_PI);
 
        const float sqrt_u1 = FMath::Sqrt(u1);
 
        const float sqrt_1_u1 = FMath::Sqrt(1 - u1);
 
 
 
        const float w = sqrt_1_u1 * FMath::Sin(u2);
 
        const float x = sqrt_1_u1 * FMath::Cos(u2);
 
        const float y = sqrt_u1 * FMath::Sin(u3);
 
        const float z = sqrt_u1 * FMath::Cos(u3);
 
 
 
        return FQuat(x, y, z, w);
 
    }
 
 
 
    FORCEINLINE static float GetRandomYawInDegrees()
 
    {
 
        return GetRandomFloatInRange(0.f, 360.f);
 
    }
 
 
 
    FORCEINLINE static float GetRandomExtent(float InMaxExtent)
 
    {
 
        return GetRandomFloatInRange(-InMaxExtent, InMaxExtent);
 
    }
 
 
 
    static FVector GetRandomSphericalPosition(const FVector& InCenter,
 
                                              const FVector2f& InDistanceRange,
 
                                              const FVector2f& InHeightRange);
 
 
 
    FORCEINLINE static FLinearColor GetRandomColorFromHSV(const float InMin = 0.6f)
 
    {
 
        FLinearColor color(GetRandomYawInDegrees(),               // Hue
 
                           GetRandomBias(),                       // Saturation
 
                           GetRandomFloatInRange(InMin, 1.f));    // Value
 
 
 
        return color.HSVToLinearRGB();
 
    }
 
 
 
    FORCEINLINE static FLinearColor GetRandomColorFromHSV(const TArray<FVector2D>& InHSVRange)
 
    {
 
        FLinearColor color(GetRandomFloatInRange(InHSVRange[0].X, InHSVRange[0].Y),     // Hue
 
                           GetRandomFloatInRange(InHSVRange[1].X, InHSVRange[1].Y),     // Saturation
 
                           GetRandomFloatInRange(InHSVRange[2].X, InHSVRange[2].Y));    // Value
 
 
 
        return color.HSVToLinearRGB();
 
    }
 
 
 
    FORCEINLINE static FLinearColor GetRandomColor()
 
    {
 
        return FLinearColor(GetRandomBias(), GetRandomBias(), GetRandomBias(), GetRandomBias());
 
    }
 
 
 
    FORCEINLINE static bool StepUpdate(double& current, const double target, const double step, const double tolerance)
 
    {
 
        bool reached = false;
 
        double diff = target - current;
 
        double absStep = FMath::Abs(step);
 
        double signedStep = diff > 0 ? absStep : -absStep;
 
        if (FMath::Abs(diff) <= absStep ||                                  //can reach target in step
 
            FMath::Abs(diff) <= FMath::Abs(tolerance) ||                    //with in tolerance
 
            (signedStep > 0 && diff < 0) || (signedStep < 0 && diff > 0)    //overshoot
 
        )
 
        {
 
            current = target;
 
            reached = true;
 
        }
 
        else
 
        {
 
            current += signedStep;
 
        }
 
 
 
        return reached;
 
    }
 
 
 
    FORCEINLINE static bool StepUpdateAngle(double& current, const double target, const double step, const double tolerance)
 
    {
 
        bool reached = false;
 
        double currentNormalized = FRotator::NormalizeAxis(current);
 
        const double targetNormalized = FRotator::NormalizeAxis(target);
 
        double diff = FRotator::NormalizeAxis(targetNormalized - currentNormalized);
 
        double absStep = FMath::Abs(step);
 
        double signedStep = diff > 0 ? absStep : -absStep;
 
        if (FMath::Abs(diff) <= absStep ||                                  //can reach target in step
 
            FMath::Abs(diff) <= FMath::Abs(tolerance) ||                    //with in tolerance
 
            (signedStep > 0 && diff < 0) || (signedStep < 0 && diff > 0)    //overshoot
 
        )
 
        {
 
            currentNormalized = targetNormalized;
 
            reached = true;
 
        }
 
        else
 
        {
 
            currentNormalized += signedStep;
 
            currentNormalized = FRotator::NormalizeAxis(currentNormalized);
 
        }
 
 
 
        current = currentNormalized;
 
        return reached;
 
    }
 
 
 
    static FRotator GetRotatorFromVectors(const FVector& Vector1, const FVector& Vector2)
 
    {
 
        float dot = FMath::RadiansToDegrees(FMath::Acos(FVector::DotProduct(Vector1, Vector2)));
 
        FVector cross = FVector::CrossProduct(Vector1, Vector2);
 
        return UKismetMathLibrary::RotatorFromAxisAndAngle(cross, dot);
 
    }
 
 
 
private:
 
    static FRandomStream RandomStream;
 
};