RBFSolver.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Animation/AnimTypes.h"
#include "Containers/Array.h"
#include "Containers/EnumAsByte.h"
#include "CoreMinimal.h"
#include "Curves/RichCurve.h"
#include "Math/Quat.h"
#include "Math/Rotator.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Templates/SharedPointer.h"
#include "UObject/ObjectMacros.h"
 
#include "RBFSolver.generated.h"
 
 
UENUM()
enum class ERBFSolverType : uint8
{
    Additive,
 
    Interpolative
};
 
UENUM()
enum class ERBFFunctionType : uint8
{
    Gaussian,
 
    Exponential,
 
    Linear,
 
    Cubic,
 
    Quintic,
 
    DefaultFunction
};
 
UENUM()
enum class ERBFDistanceMethod : uint8
{
    Euclidean,
 
    Quaternion,
 
    SwingAngle,
 
    TwistAngle,
 
    DefaultMethod
};
 
UENUM()
enum class ERBFNormalizeMethod : uint8
{
    OnlyNormalizeAboveOne,
 
    AlwaysNormalize,
 
    NormalizeWithinMedian,
 
    NoNormalization,
 
};
 
USTRUCT()
struct FRBFEntry
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category = RBFData)
    TArray<float> Values;
 
    ANIMGRAPHRUNTIME_API FRotator AsRotator(int32 Index) const;
 
    ANIMGRAPHRUNTIME_API FQuat AsQuat(int32 Index) const;
 
    ANIMGRAPHRUNTIME_API FVector AsVector(int32 Index) const;
 
 
    ANIMGRAPHRUNTIME_API void AddFromRotator(const FRotator& InRot);
    ANIMGRAPHRUNTIME_API void AddFromVector(const FVector& InVector);
 
    int32 GetDimensions() const
    {
        return Values.Num();
    }
};
 
USTRUCT()
struct FRBFTarget : public FRBFEntry
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category = RBFData)
    float ScaleFactor;
 
    UPROPERTY(EditAnywhere, Category = RBFData)
    bool bApplyCustomCurve;
 
    UPROPERTY(EditAnywhere, Category = RBFData)
    FRichCurve CustomCurve;
 
    UPROPERTY(EditAnywhere, Category = RBFData)
    ERBFDistanceMethod DistanceMethod;
 
    UPROPERTY(EditAnywhere, Category = RBFData)
    ERBFFunctionType FunctionType;
 
    FRBFTarget()
        : ScaleFactor(1.f)
        , bApplyCustomCurve(false)
        , DistanceMethod(ERBFDistanceMethod::DefaultMethod)
        , FunctionType(ERBFFunctionType::DefaultFunction)
    {}
};
 
struct FRBFOutputWeight
{
    int32 TargetIndex;
    float TargetWeight;
 
    FRBFOutputWeight(int32 InTargetIndex, float InTargetWeight)
        : TargetIndex(InTargetIndex)
        , TargetWeight(InTargetWeight)
    {}
 
    FRBFOutputWeight()
        : TargetIndex(0)
        , TargetWeight(0.f)
    {}
};
 
USTRUCT(BlueprintType)
struct FRBFParams
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    int32 TargetDimensions;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData)
    ERBFSolverType SolverType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData, meta = (EditCondition = "!bAutomaticRadius"))
    float Radius;
 
    /* Automatically pick the radius based on the average distance between targets */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData)
    bool bAutomaticRadius;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData)
    ERBFFunctionType Function;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData)
    ERBFDistanceMethod DistanceMethod;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData)
    TEnumAsByte<EBoneAxis> TwistAxis;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData)
    float WeightThreshold;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData)
    ERBFNormalizeMethod NormalizeMethod;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData, meta = (EditCondition = "NormalizeMethod == ERBFNormalizeMethod::NormalizeWithinMedian"))
    FVector MedianReference;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData, meta = (UIMin = "0", UIMax = "90", EditCondition = "NormalizeMethod == ERBFNormalizeMethod::NormalizeWithinMedian"))
    float MedianMin;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RBFData, meta = (UIMin = "0", UIMax = "90", EditCondition = "NormalizeMethod == ERBFNormalizeMethod::NormalizeWithinMedian"))
    float MedianMax;
 
    ANIMGRAPHRUNTIME_API FRBFParams();
 
    ANIMGRAPHRUNTIME_API FVector GetTwistAxisVector() const;
};
 
struct ANIMGRAPHRUNTIME_API FRBFSolverData;
 
struct FRBFSolver
{
    static ANIMGRAPHRUNTIME_API bool ValidateTargets(const FRBFParams& Params, const TArray<FRBFTarget>& Targets, TArray<int>& InvalidTargets);
 
    static ANIMGRAPHRUNTIME_API TSharedPtr<const FRBFSolverData> InitSolver(const FRBFParams& Params, const TArray<FRBFTarget>& Targets);
 
    static ANIMGRAPHRUNTIME_API bool IsSolverDataValid(const FRBFSolverData& SolverData, const FRBFParams& Params, const TArray<FRBFTarget>& Targets);
 
    static ANIMGRAPHRUNTIME_API void Solve(const FRBFSolverData& SolverData, const FRBFParams& Params, const TArray<FRBFTarget>& Targets, const FRBFEntry& Input, TArray<FRBFOutputWeight>& OutputWeights);
 
    static ANIMGRAPHRUNTIME_API bool FindTargetNeighbourDistances(const FRBFParams& Params, const TArray<FRBFTarget>& Targets, TArray<float>& NeighbourDists);
 
    static ANIMGRAPHRUNTIME_API float FindDistanceBetweenEntries(const FRBFEntry& A, const FRBFEntry& B, const FRBFParams& Params, ERBFDistanceMethod OverrideMethod = ERBFDistanceMethod::DefaultMethod);
 
    static ANIMGRAPHRUNTIME_API float GetRadiusForTarget(const FRBFTarget& Target, const FRBFParams& Params);
 
    static ANIMGRAPHRUNTIME_API float GetOptimalRadiusForTargets(const FRBFParams& Params, const TArray<FRBFTarget>& Targets);
};