ManagedArrayCollection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GeometryCollection/ManagedArray.h"
#include "GeometryCollection/ManagedArrayTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "GeometryCollection/GeometryCollectionSection.h"
 
#include "ManagedArrayCollection.generated.h"
 
class FSimulationProperties;
 
namespace Chaos
{
    class FChaosArchive;
}
 
struct FAttributeAndGroupId
{
    FName AttributeName;
    FName GroupName;
 
    bool operator==(const FAttributeAndGroupId& Other) const
    {
        return ((AttributeName == Other.AttributeName) && (GroupName == Other.GroupName));
    }
};
 
USTRUCT()
struct FManagedArrayCollection
{
    GENERATED_USTRUCT_BODY()
    friend FSimulationProperties;
 
public:
 
 
    CHAOS_API FManagedArrayCollection();
    CHAOS_API virtual ~FManagedArrayCollection();
 
    CHAOS_API FManagedArrayCollection(const FManagedArrayCollection& In);
    CHAOS_API FManagedArrayCollection& operator=(const FManagedArrayCollection& In);
    CHAOS_API FManagedArrayCollection(FManagedArrayCollection&&);
    CHAOS_API FManagedArrayCollection& operator=(FManagedArrayCollection&&);
 
    CHAOS_API bool operator==(const FManagedArrayCollection& Other) const;  // Slow, required for comparing to a default collection during UPROPERTY serialization
 
    static CHAOS_API int8 Invalid;
    typedef EManagedArrayType EArrayType;
    struct FConstructionParameters {
 
        FConstructionParameters(FName GroupIndexDependencyIn = NAME_None
            , bool SavedIn = true, bool bInAllowCircularDependency = false)
            : GroupIndexDependency(GroupIndexDependencyIn)
            , Saved(SavedIn)
            , bAllowCircularDependency(bInAllowCircularDependency)
        {}
 
        FName GroupIndexDependency;
        bool Saved;
        bool bAllowCircularDependency;
    };
 
    struct FProcessingParameters
    {
        FProcessingParameters() : bDoValidation(true), bReindexDependentAttibutes(true) {}
 
        bool bDoValidation ;
        bool bReindexDependentAttibutes;
    };
 
    struct FManagedType
    {
        FManagedType(EManagedArrayType InType, FName InName, FName InGroup)
            : Type(InType), Name(InName), Group(InGroup) {}
        EManagedArrayType Type = EManagedArrayType::FNoneType;
        FName Name = "";
        FName Group = "";
    };
 
    template<class T>
    struct TManagedType : FManagedType
    {
        TManagedType(FName InName, FName InGroup) :
            FManagedType(ManagedArrayType<T>(), InName, InGroup) {}         
    };
 
    static FName StaticType() { return FName("FManagedArrayCollection"); }
 
    virtual bool IsAType(FName InTypeName) const { return InTypeName.IsEqual(FManagedArrayCollection::StaticType()); }
 
    template<typename T>
    bool IsA() { return IsAType(T::StaticType()); }
 
    template<class T>
    T* Cast() { return IsAType(T::StaticType())?static_cast<T*>(this):nullptr; }
 
    template<class T>
    const T* Cast() const { return IsAType(T::StaticType())? static_cast<const T*>(this) : nullptr; }
 
    template<typename T>
    TManagedArray<T>& AddAttribute(FName Name, FName Group, FConstructionParameters Parameters = FConstructionParameters())
    {
        if (!HasAttribute(Name, Group))
        {
            AddNewAttributeImpl<T>(Name, Group, Parameters);
        }
        return ModifyAttribute<T>(Name, Group);
    }
 
    template<typename T>
    TManagedArray<T>* FindOrAddAttributeTyped(FName Name, FName Group, FConstructionParameters Parameters = FConstructionParameters())
    {
        if (!HasAttribute(Name, Group))
        {
            AddNewAttributeImpl<T>(Name, Group, Parameters);
        }
        return ModifyAttributeTyped<T>(Name, Group);
    }
 
 
    template<class T = FManagedArrayCollection>
    T* NewCopy() const
    {
        T* Collection = new T();
        for (const FName& GroupName : Collection->GroupNames())
        {
            Collection->EmptyGroup(GroupName); //Geometry collection has 1 element in ConvexProperties group when initialized
        }
        CopyTo(Collection);
        return Collection;
    }
 
    void CopyTo(FManagedArrayCollection* Collection, const TArray<FName>& GroupsToSkip = TArray<FName>(), TArray<TTuple<FName, FName>> AttributesToSkip = TArray<TTuple<FName, FName>>()) const
    {
        if (!Map.IsEmpty())
        {
            for (const TTuple<FKeyType, FValueType>& Entry : Map)
            {
                const FName& AttributeName = Entry.Key.Get<0>();
                const FName& GroupName = Entry.Key.Get<1>();
                if (AttributesToSkip.Num() > 0)
                {
                    const TTuple<FName, FName> GroupAndAttribute{ AttributeName, GroupName };
                    if (AttributesToSkip.Contains(GroupAndAttribute))
                    {
                        continue;
                    }
                }
                if (!GroupsToSkip.Contains(GroupName))
                {
                    if (!Collection->HasGroup(GroupName))
                    {
                        Collection->AddGroup(GroupName);
                    }
 
                    if (NumElements(GroupName) != Collection->NumElements(GroupName))
                    {
                        ensure(!Collection->NumElements(GroupName));
                        Collection->AddElements(NumElements(GroupName), GroupName);
                    }
 
                    Collection->CopyAttribute(*this, AttributeName, GroupName);
                }
            }
        }
    }
 
    template<typename T>
    void AddExternalAttribute(FName Name, FName Group, TManagedArray<T>& ValueIn, FConstructionParameters Parameters = FConstructionParameters())
    {
        check(!HasAttribute(Name, Group));
 
        if (!HasGroup(Group))
        {
            AddGroup(Group);
        }
 
        const int32 InitialSize = NumElements(Group);
        FName GroupIndexDependency;
        if (ensure(Parameters.bAllowCircularDependency || !IsConnected(Parameters.GroupIndexDependency, Group)))
        {
            GroupIndexDependency = Parameters.GroupIndexDependency;
        }
        else
        {
            GroupIndexDependency = NAME_None;
        }
 
        FValueType NewAttribute = FValueType::MakeExternal<T>(&ValueIn, NumElements(Group), GroupIndexDependency, Parameters.Saved);
        Map.Add({ Name, Group }, MoveTemp(NewAttribute));
    }
 
    CHAOS_API void AddGroup(FName Group);
 
    CHAOS_API int32 NumAttributes(FName Group) const;
 
    CHAOS_API TArray<FName> AttributeNames(FName Group) const;
 
    CHAOS_API int32 AddElements(int32 NumberElements, FName Group);
 
    CHAOS_API int32 InsertElements(int32 NumberElements, int32 Position, FName Group);
 
    CHAOS_API virtual void Append(const FManagedArrayCollection& Collection);
 
    template<typename T>
    TManagedArray<T>* FindAttribute(FName Name, FName Group)
    {
        const FKeyType Key = FManagedArrayCollection::MakeMapKey(Name, Group);
        if (FValueType* FoundValue = Map.Find(Key))
        {
            return FoundValue->ModifyTypedPtr<T>();
        }
        return nullptr;
    };
 
    template<typename T>
    const TManagedArray<T>* FindAttribute(FName Name, FName Group) const
    {
        if (const FValueType* FoundValue = Map.Find({ Name, Group }))
        {
            return FoundValue->GetTypedPtr<T>();
        }
        return nullptr;
    };
 
    template<typename T>
    TManagedArray<T>* FindAttributeTyped(FName Name, FName Group)
    {
        if (FValueType* FoundValue = Map.Find({ Name, Group }))
        {
            if(FoundValue->IsSameType<T>())
            {
                return FoundValue->ModifyTypedPtr<T>();
            }
        }
        return nullptr;
    };
 
    template<typename T>
    const TManagedArray<T>* FindAttributeTyped(FName Name, FName Group) const
    {
        if (const FValueType* FoundValue = Map.Find({ Name, Group }))
        {
            if(FoundValue->IsSameType<T>())
            {
                return FoundValue->GetTypedPtr<T>();
            }
        }
        return nullptr;
    };
 
    template<typename T>
    TManagedArray<T>& ModifyAttribute(FName Name, FName Group)
    {
        check(HasAttribute(Name, Group))
        return Map[{Name, Group}].ModifyTyped<T>();
    }
 
    template<typename T>
    TManagedArray<T>* ModifyAttributeTyped(FName Name, FName Group)
    {
        if (FValueType* FoundValue = Map.Find({ Name, Group }))
        {
            if (FoundValue->IsSameType<T>())
            {
                return FoundValue->ModifyTypedPtr<T>();
            }
        }
        return nullptr;
    }
    
    template<typename T>
    const TManagedArray<T>& GetAttribute(FName Name, FName Group) const
    {
        check(HasAttribute(Name, Group));
        return Map[{Name, Group}].GetTyped<T>();
    };
 
    virtual void Reset() { Map.Reset(); GroupInfo.Reset(); MakeDirty(); }
 
 
    CHAOS_API virtual void RemoveElements(const FName & Group, const TArray<int32> & SortedDeletionList, FProcessingParameters Params = FProcessingParameters());
 
    CHAOS_API virtual void MergeElements(const FName& Group, const TArray<int32>& SortedMergeList, const TArray<int32>& MergeRemapIndex, FProcessingParameters Params = FProcessingParameters());
 
    CHAOS_API virtual void RemoveElements(const FName& Group, int32 NumberElements, int32 Position);
 
 
    CHAOS_API void RemoveAttribute(FName Name, FName Group);
 
 
    CHAOS_API void RemoveGroup(FName Group);
 
    CHAOS_API TArray<FName> GroupNames() const;
 
    bool IsEmpty() const
    {
        return GroupInfo.IsEmpty() && Map.IsEmpty();
    }
 
    CHAOS_API bool HasAttribute(FName Name, FName Group) const;
 
    CHAOS_API bool HasAttributes(const TArray<FManagedType>& Types) const;
 
    FORCEINLINE bool HasGroup(FName Group) const { return GroupInfo.Contains(Group); }
 
    CHAOS_API EArrayType GetAttributeType(FName Name, FName Group) const;
 
    CHAOS_API bool IsAttributeDirty(FName Name, FName Group) const;
 
    CHAOS_API bool IsAttributePersistent(FName Name, FName Group) const;
    
    CHAOS_API void SetDependency(FName Name, FName Group, FName DependencyGroup, bool bAllowCircularDependency = false);
 
    CHAOS_API FName GetDependency(FName Name, FName Group) const;
 
    CHAOS_API void RemoveDependencyFor(FName Group);
 
    CHAOS_API void CopyAttribute(const FManagedArrayCollection& InCollection, FName Name, FName Group);
 
    CHAOS_API void CopyAttribute(const FManagedArrayCollection& InCollection, FName SrcName, FName DestName, FName Group);
 
    CHAOS_API void CopyAttribute(const FManagedArrayCollection& InCollection, FName SrcName, FName DestName, FName SrcGroup, FName DstGroup);
 
    CHAOS_API void CopyMatchingAttributesFrom(const FManagedArrayCollection& InCollection, const TMap<FName, TSet<FName>>* SkipList=nullptr);
 
    CHAOS_API void CopyMatchingAttributesFrom(const FManagedArrayCollection& FromCollection, const TArrayView<const FAttributeAndGroupId> SkipList);
 
    CHAOS_API int32 NumElements(FName Group) const;
 
    CHAOS_API void Resize(int32 Size, FName Group);
 
    CHAOS_API void Reserve(int32 Size, FName Group);
 
    CHAOS_API void EmptyGroup(FName Group);
 
    CHAOS_API virtual void ReorderElements(FName Group, const TArray<int32>& NewOrder);
#if 0   //not needed until we support per instance serialization
    CHAOS_API void SwapElements(int32 Index1, int32 Index2, FName Group);
#endif
 
    void MakeDirty() { bDirty = true; }
    void MakeClean() { bDirty = false; }
    bool IsDirty() const { return bDirty; }
 
    CHAOS_API virtual void Serialize(Chaos::FChaosArchive& Ar);
 
    CHAOS_API bool Serialize(FArchive& Ar);
 
    CHAOS_API bool IsConnected(FName StartingNode, FName TargetNode);
 
 
    CHAOS_API FString ToString() const;
 
    CHAOS_API SIZE_T GetAllocatedSize() const;
 
     CHAOS_API void GetElementSizeInfoForGroups(TArray<TPair<FName, SIZE_T>>& OutSizeInfo) const;
 
private:
 
    template<typename T>
    void AddNewAttributeImpl(FName Name, FName Group, const FConstructionParameters& Parameters)
    {
        checkSlow(!HasAttribute(Name, Group));
        if (!HasGroup(Group))
        {
            AddGroup(Group);
        }
 
        static const FName EmptyName = NAME_None;
        
        const int32 InitialSize = NumElements(Group);
        FName GroupIndexDependency;
        if (ensure(Parameters.bAllowCircularDependency || !IsConnected(Parameters.GroupIndexDependency, Group)))
        {
            GroupIndexDependency = Parameters.GroupIndexDependency;
        }
        else
        {
            GroupIndexDependency = EmptyName;
        }
 
        TUniquePtr<TManagedArray<T>> ArrayPtr(new TManagedArray<T>());
        FValueType NewAttribute = FValueType::MakeManaged(MoveTemp(ArrayPtr), InitialSize, GroupIndexDependency, Parameters.Saved);
        Map.Add({ Name, Group }, MoveTemp(NewAttribute));
    }
 
    TArray<int32> InsertElementsNoReorder(int32 NumberElements, int32 Position, FName Group);
 
    /****
    *  Mapping Key/Value
    *
    *    The Key and Value pairs for the attribute arrays allow for grouping
    *    of array attributes based on the Name,Group pairs. Array attributes
    *    that share Group names will have the same lengths.
    *
    *    The FKeyType is a tuple of <FName,FName> where the Get<0>() parameter
    *    is the AttributeName, and the Get<1>() parameter is the GroupName.
    *    Construction of the FKeyType will follow the following pattern:
    *    FKeyType("AttributeName","GroupName");
    *
    */
    typedef TTuple<FName, FName> FKeyType;
    struct FGroupInfo
    {
        int32 Size;
    };
 
    static inline FKeyType MakeMapKey(FName Name, FName Group) // inline for linking issues
    {
        return FKeyType(Name, Group);
    }
 
    friend struct FManagedArrayCollectionValueTypeWrapper;
    struct FValueType
    {
    private:
        EArrayType ArrayType;
        FName GroupIndexDependency;
        bool bPersistent;
        bool bExternalValue;    //External arrays have external memory management.
 
        TSharedPtr<FManagedArrayBase, ESPMode::ThreadSafe> SharedManagedArray; // external arrays have this set this to null
        FManagedArrayBase* ManagedArray = nullptr;;
 
    private:
        template<typename T>
        FValueType(TUniquePtr<TManagedArray<T>>&& ArrayPtr, int32 InitialSize, FName InGroupIndexDependency, bool bInPersistent)
            : ArrayType(ManagedArrayType<T>())
            , GroupIndexDependency(InGroupIndexDependency)
            , bPersistent(bInPersistent)
            , bExternalValue(false)
            , SharedManagedArray(ArrayPtr.Release())
            , ManagedArray(SharedManagedArray.Get())
        {
            MakeUniqueForWrite();
            ManagedArray->Reserve(InitialSize); // make sure we have the exact size to avoid over-allocation
            ManagedArray->Resize(InitialSize);
        };
 
        template<typename T>
        FValueType(TManagedArray<T>* ExternalArrayPtr, int32 InitialSize, FName InGroupIndexDependency, bool bInPersistent)
            : ArrayType(ManagedArrayType<T>())
            , GroupIndexDependency(InGroupIndexDependency)
            , bPersistent(bInPersistent)
            , bExternalValue(true)
            , SharedManagedArray(nullptr)
            , ManagedArray(ExternalArrayPtr)
        {
            ManagedArray->Reserve(InitialSize); // make sure we have the exact size to avoid over-allocation
            ManagedArray->Resize(InitialSize);
        };
 
        CHAOS_API void MakeUniqueForWrite();
 
    public:
        template <typename T>
        static FValueType MakeManaged(TUniquePtr<TManagedArray<T>>&& ArrayPtr, int32 InitialSize, FName InGroupIndexDependency, bool bInPersistent)
        {
            return FValueType(MoveTemp(ArrayPtr), InitialSize, InGroupIndexDependency, bInPersistent);
        }
 
        template <typename T>
        static FValueType MakeExternal(TManagedArray<T>* ExternalArrayPtr, int32 InitialSize, FName InGroupIndexDependency, bool bInPersistent)
        {
            return FValueType(ExternalArrayPtr, InitialSize, InGroupIndexDependency, bInPersistent);
        }
 
        CHAOS_API FValueType();
        CHAOS_API FValueType(const FValueType& Other);
        CHAOS_API FValueType(FValueType&& Other);
 
        CHAOS_API ~FValueType();
 
        EArrayType GetArrayType() const { return ArrayType; }
        FName GetGroupIndexDependency() const { return GroupIndexDependency; };
        bool IsPersistent() const { return bPersistent; }
        bool IsExternal() const { return bExternalValue; }
        bool IsDirty() const { return ManagedArray->IsDirty(); }
 
        void SetGroupIndexDependency(FName NewGroupDependency) { GroupIndexDependency = NewGroupDependency; }
 
        template <typename T>
        bool IsSameType() const { return (ArrayType == ManagedArrayType<T>()); }
        
        template <typename T>
        const TManagedArray<T>* GetTypedPtr() const
        { 
            check(IsSameType<T>());
            
            const TManagedArray<T>* TypedManagedArray = static_cast<const TManagedArray<T>*>(ManagedArray);
            check(TypedManagedArray != nullptr);
            return TypedManagedArray;
        }
 
        template <typename T>
        const TManagedArray<T>& GetTyped() const
        {
            return *GetTypedPtr<T>();
        }
 
        const FManagedArrayBase& Get() const { return *ManagedArray; }
 
        template <typename T>
        TManagedArray<T>* ModifyTypedPtr()
        { 
            check(IsSameType<T>());
            MakeUniqueForWrite();
 
            TManagedArray<T>* TypedManagedArray = static_cast<TManagedArray<T>*>(ManagedArray);
            check(TypedManagedArray != nullptr);
 
            TypedManagedArray->MarkDirty();
            return TypedManagedArray;
        }
 
        template <typename T>
        TManagedArray<T>& ModifyTyped()
        {
            return *ModifyTypedPtr<T>();
        }
 
        FManagedArrayBase& Modify();
 
        void Reserve(int32 ReservedSize);
        void Resize(int32 NewSize);
        void InitFrom(const FValueType& Other);
        void Exchange(FValueType& Other);
        void Convert(FValueType& Other);
        void CopyFrom(const FValueType& Other);
        void Empty();
        void RemoveGroupIndexDependency(FName Group);
 
        FValueType& operator=(const FValueType& Other) = delete;
        FValueType& operator=(FValueType&& Other) = delete;
 
        void Serialize(FArchive& Ar);
    };
 
 
    TMap< FKeyType, FValueType> Map;    //data is owned by the map explicitly
    TMap< FName, FGroupInfo> GroupInfo;
    bool bDirty;
 
protected:
 
    CHAOS_API virtual void SetDefaults(FName Group, uint32 StartSize, uint32 NumElements);
 
    virtual void MatchOptionalDefaultAttributes(const FManagedArrayCollection& InCollection)
    {}
 
    CHAOS_API void SyncGroupSizeFrom(const FManagedArrayCollection& InCollection, FName Group);
    
    CHAOS_API void SyncGroupSizeFrom(const FManagedArrayCollection& InCollection, FName SrcGroup, FName DstGroup);
 
    int32 Version;
 
 
    friend FArchive& operator<<(FArchive& Ar, FGroupInfo& GroupInfo);
 
    friend FArchive& operator<<(FArchive& Ar, FValueType& ValueIn);
 
};
 
template<> struct TStructOpsTypeTraits<FManagedArrayCollection> : public TStructOpsTypeTraitsBase2<FManagedArrayCollection>
{
    enum
    {
        WithSerializer = true,
        WithIdenticalViaEquality = true  // Required for usage as a UPROPERTY, otherwise the reflection system won't see a difference with a default collection when serializing
    };
};
 
/*
*  FManagedArrayInterface
*/
class FManagedArrayInterface
{
public:
    FManagedArrayInterface() : ManagedCollection(nullptr) {}
    FManagedArrayInterface(FManagedArrayCollection* InManagedArray)
        : ManagedCollection(InManagedArray) {}
 
    virtual void InitializeInterface() = 0;
    virtual void CleanInterfaceForCook() = 0; 
    virtual void RemoveInterfaceAttributes() = 0;
 
protected:
    FManagedArrayCollection* ManagedCollection;
 
};
 
 
#define MANAGED_ARRAY_COLLECTION_INTERNAL(TYPE_NAME)                    \
    static FName StaticType() { return FName(#TYPE_NAME); }             \
    virtual bool IsAType(FName InTypeName) const override {             \
        return InTypeName.IsEqual(TYPE_NAME::StaticType())              \
                || Super::IsAType(InTypeName);                          \
    }