CurveTable.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
#include "Policies/PrettyJsonPrintPolicy.h"
#include "Curves/CurveOwnerInterface.h"
#include "Curves/SimpleCurve.h"
#include "CurveTable.generated.h"
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogCurveTable, Log, All);
 
 
// forward declare JSON writer
template <class CharType>
struct TPrettyJsonPrintPolicy;
template <class CharType, class PrintPolicy>
class TJsonWriter;
 
UENUM()
enum class ECurveTableMode : uint8
{
    Empty,
    SimpleCurves,
    RichCurves
};
 
 
UCLASS(MinimalAPI, Meta = (LoadBehavior = "LazyOnDemand"))
class UCurveTable
    : public UObject
    , public FCurveOwnerInterface
{
    GENERATED_UCLASS_BODY()
 
    DECLARE_MULTICAST_DELEGATE(FOnCurveTableChanged);
 
    const TMap<FName, FRealCurve*>& GetRowMap() const { return RowMap; }
    const TMap<FName, FRealCurve*>& GetRowMap() { return RowMap; }
 
    const TMap<FName, FRichCurve*>& GetRichCurveRowMap() const { check(CurveTableMode != ECurveTableMode::SimpleCurves); return *reinterpret_cast<const TMap<FName, FRichCurve*>*>(&RowMap); }
    const TMap<FName, FRichCurve*>& GetRichCurveRowMap() { check(CurveTableMode != ECurveTableMode::SimpleCurves); return *reinterpret_cast<TMap<FName, FRichCurve*>*>(&RowMap); }
 
    const TMap<FName, FSimpleCurve*>& GetSimpleCurveRowMap() const { check(CurveTableMode != ECurveTableMode::RichCurves); return *reinterpret_cast<const TMap<FName, FSimpleCurve*>*>(&RowMap); }
    const TMap<FName, FSimpleCurve*>& GetSimpleCurveRowMap() { check(CurveTableMode != ECurveTableMode::RichCurves);  return *reinterpret_cast<TMap<FName, FSimpleCurve*>*>(&RowMap); }
 
    ECurveTableMode GetCurveTableMode() const { return CurveTableMode; }
 
    ENGINE_API virtual void RemoveRow(FName RowName);
    ENGINE_API FRichCurve& AddRichCurve(FName RowName);
    ENGINE_API FSimpleCurve& AddSimpleCurve(FName RowName);
 
    ENGINE_API void RenameRow(FName& CurveName, FName& NewCurveName);
 
    ENGINE_API void DeleteRow(FName& CurveName);
 
protected:
    TMap<FName, FRealCurve*>    RowMap;
 
    static FTransactionallySafeCriticalSection& GetCurveTableChangeCriticalSection();
 
public:
    //~ Begin UObject Interface.
    virtual void FinishDestroy() override;
    virtual void Serialize( FArchive& Ar ) override;
 
#if WITH_EDITORONLY_DATA
    virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
    virtual void PostInitProperties() override;
    virtual void PostLoad() override;
 
    UPROPERTY(VisibleAnywhere, Instanced, Category=ImportSettings)
    TObjectPtr<class UAssetImportData> AssetImportData;
 
    UPROPERTY()
    FString ImportPath_DEPRECATED;
 
#endif  // WITH_EDITORONLY_DATA
 
    //~ End  UObject Interface
 
    //~ Begin FCurveOwnerInterface Interface.
    UE_DEPRECATED(5.6, "Use version taking a TAdderReserverRef")
    virtual TArray<FRichCurveEditInfoConst> GetCurves() const override;
    virtual void GetCurves(TAdderReserverRef<FRichCurveEditInfoConst> Curves) const override;
    virtual TArray<FRichCurveEditInfo> GetCurves() override;
    virtual void ModifyOwner() override;
    virtual void MakeTransactional() override;
    virtual void OnCurveChanged(const TArray<FRichCurveEditInfo>& ChangedCurveEditInfos) override;
    virtual bool IsValidCurve(FRichCurveEditInfo CurveInfo) override;
    virtual TArray<const UObject*> GetOwners() const override;
    virtual bool RepointCurveOwner(const FPackageReloadedEvent& InPackageReloadedEvent, FCurveOwnerInterface*& OutNewCurveOwner) const override
    {
        return RepointCurveOwnerAsset(InPackageReloadedEvent, this, OutNewCurveOwner);
    }
    virtual bool HasRichCurves() const override
    {
        return CurveTableMode != ECurveTableMode::SimpleCurves;
    }
    //~ End FCurveOwnerInterface Interface.
 
    FOnCurveTableChanged& OnCurveTableChanged() { return OnCurveTableChangedDelegate; }
 
    //~ Begin UCurveTable Interface
 
    FRealCurve* FindCurve(FName RowName, const FString& ContextString, bool bWarnIfNotFound = true) const
    {
        if (RowName.IsNone())
        {
            UE_CLOG(bWarnIfNotFound, LogCurveTable, Warning, TEXT("UCurveTable::FindCurve : NAME_None is invalid row name for CurveTable '%s' (%s)."), *GetPathName(), *ContextString);
            return nullptr;
        }
 
        FRealCurve* const* FoundCurve = RowMap.Find(RowName);
 
        if (FoundCurve == nullptr)
        {
            UE_CLOG(bWarnIfNotFound, LogCurveTable, Warning, TEXT("UCurveTable::FindCurve : Row '%s' not found in CurveTable '%s' (%s)."), *RowName.ToString(), *GetPathName(), *ContextString);
            return nullptr;
        }
 
        return *FoundCurve;
    }
 
    FRichCurve* FindRichCurve(FName RowName, const FString& ContextString, bool bWarnIfNotFound = true) const
    {
        if (CurveTableMode == ECurveTableMode::SimpleCurves)
        {
            UE_LOG(LogCurveTable, Error, TEXT("UCurveTable::FindCurve : Using FindRichCurve on CurveTable '%s' (%s) that is storing simple curves."), *GetPathName(), *ContextString);
            return nullptr;
        }
 
        return (FRichCurve*)FindCurve(RowName, ContextString, bWarnIfNotFound);
    }
 
    FSimpleCurve* FindSimpleCurve(FName RowName, const FString& ContextString, bool bWarnIfNotFound = true) const
    {
        if (CurveTableMode == ECurveTableMode::RichCurves)
        {
            UE_LOG(LogCurveTable, Error, TEXT("UCurveTable::FindCurve : Using FindSimpleCurve on CurveTable '%s' (%s) that is storing rich curves."), *GetPathName(), *ContextString);
            return nullptr;
        }
 
        return (FSimpleCurve*)FindCurve(RowName, ContextString, bWarnIfNotFound);
    }
 
    FRealCurve* FindCurveUnchecked(FName RowName) const
    {
        // If RowName is none, it won't be found in the map
        FRealCurve* const* FoundCurve = RowMap.Find(RowName);
 
        if (FoundCurve == nullptr)
        {
            return nullptr;
        }
 
        return *FoundCurve;
    }
 
    ENGINE_API FString GetTableAsString() const;
 
    ENGINE_API FString GetTableAsCSV() const;
 
    ENGINE_API FString GetTableAsJSON() const;
 
    template <typename CharType = TCHAR>
    bool WriteTableAsJSON(const TSharedRef< TJsonWriter<CharType, TPrettyJsonPrintPolicy<CharType> > >& JsonWriter,bool bAsArray = true) const;
 
    ENGINE_API TArray<FString> CreateTableFromCSVString(const FString& InString, ERichCurveInterpMode InterpMode = RCIM_Linear);
 
    ENGINE_API TArray<FString> CreateTableFromJSONString(const FString& InString, ERichCurveInterpMode InterpMode = RCIM_Linear);
    
    ENGINE_API TArray<FString> CreateTableFromOtherTable(const UCurveTable* InTable);
 
    ENGINE_API virtual void EmptyTable();
 
    ENGINE_API static void InvalidateAllCachedCurves();
 
    static int32 GetGlobalCachedCurveID()
    {
        return GlobalCachedCurveID;
    }
 
#if WITH_EDITOR
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
 
protected:
 
    static FName MakeValidName(const FString& InString);
 
    ENGINE_API static int32 GlobalCachedCurveID;
 
 
private:
 
    FOnCurveTableChanged OnCurveTableChangedDelegate;
 
protected:
    ECurveTableMode CurveTableMode;
};
 
 
USTRUCT(BlueprintType)
struct FCurveTableRowHandle
{
    GENERATED_USTRUCT_BODY()
 
    FCurveTableRowHandle()
        : CurveTable(nullptr)
        , RowName(NAME_None)
    { }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CurveTableRowHandle, meta=(DisplayThumbnail="false"))
    TObjectPtr<const class UCurveTable> CurveTable;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CurveTableRowHandle)
    FName               RowName;
 
    bool IsValid(const FString& ContextString) const
    {
        return (GetCurve(ContextString, false) != nullptr);
    }
 
    bool IsNull() const
    {
        return CurveTable == nullptr && RowName.IsNone();
    }
 
    ENGINE_API FRealCurve* GetCurve(const FString& ContextString, bool bWarnIfNotFound=true) const;
 
    ENGINE_API FRichCurve* GetRichCurve(const FString& ContextString, bool bWarnIfNotFound=true) const;
 
    ENGINE_API FSimpleCurve* GetSimpleCurve(const FString& ContextString, bool bWarnIfNotFound = true) const;
 
    float Eval(float XValue,const FString& ContextString) const
    {
        float Result = 0.f;
        Eval(XValue, &Result, ContextString);
        return Result;
    }
 
    ENGINE_API bool Eval(float XValue, float* YValue,const FString& ContextString) const;
 
    ENGINE_API bool operator==(const FCurveTableRowHandle& Other) const;
    ENGINE_API bool operator!=(const FCurveTableRowHandle& Other) const;
    ENGINE_API void PostSerialize(const FArchive& Ar);
 
    inline friend uint32 GetTypeHash(const FCurveTableRowHandle& Handle)
    {
        return HashCombine(GetTypeHash(Handle.RowName), PointerHash(Handle.CurveTable));
    }
};
 
template<>
struct TStructOpsTypeTraits< FCurveTableRowHandle > : public TStructOpsTypeTraitsBase2< FCurveTableRowHandle >
{
    enum
    {
        WithPostSerialize = true,
    };
};
 
#define GETCURVE_REPORTERROR(Handle) Handle.GetCurve(FString::Printf(TEXT("%s.%s"), *GetPathName(), TEXT(#Handle)))
 
#define GETCURVE_REPORTERROR_WITHPATHNAME(Handle, PathNameString) Handle.GetCurve(FString::Printf(TEXT("%s.%s"), *PathNameString, TEXT(#Handle)))