DynamicAttribute.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "DynamicMesh/DynamicMesh3.h"
#include "MeshIndexMappings.h"
#include "Serialization/NameAsStringProxyArchive.h"
 
namespace UE
{
namespace Geometry
{
 
struct FMeshIndexMappings;
 
template<typename ParentType>
class TDynamicAttributeBase;
 
template<typename ParentType>
class TDynamicAttributeChangeBase
{
public:
    virtual ~TDynamicAttributeChangeBase()
    {
    }
 
    // default do-nothing implementations are provided because many attribute layers will only care about some kinds of elements and won't implement all of these
 
    virtual void SaveInitialTriangle(const TDynamicAttributeBase<ParentType>* Attribute, int TriangleID)
    {
    }
    virtual void SaveInitialVertex(const TDynamicAttributeBase<ParentType>* Attribute, int VertexID)
    {
    }
 
    virtual void StoreAllFinalTriangles(const TDynamicAttributeBase<ParentType>* Attribute, const TArray<int>& TriangleIDs)
    {
    }
    UE_DEPRECATED(5.6, "Use the version of this method that takes a TSet instead")
    virtual void StoreAllFinalVertices(const TDynamicAttributeBase<ParentType>* Attribute, const TArray<int>& TriangleIDs)
    {
        ensure(false);
    }
    virtual void StoreAllFinalVertices(const TDynamicAttributeBase<ParentType>* Attribute, const TSet<int>& TriangleIDs)
    {
    }
 
    virtual bool Apply(TDynamicAttributeBase<ParentType>* Attribute, bool bRevert) const
    {
        return false;
    }
};
 
typedef TDynamicAttributeChangeBase<FDynamicMesh3> FDynamicMeshAttributeChangeBase;
 
 
template<typename ParentType>
class TDynamicAttributeBase
{
 
public:
    virtual ~TDynamicAttributeBase()
    {
    }
 
 
public:
    FName GetName() const { return Name; }
 
    void SetName(FName NameIn) { Name = NameIn; }
 
protected:
    FName Name = FName();
 
 
 
 
public:
 
 
    virtual TDynamicAttributeBase* MakeCopy(ParentType* ParentIn) const = 0;
    virtual TDynamicAttributeBase* MakeNew(ParentType* ParentIn) const = 0;
    virtual TDynamicAttributeBase* MakeCompactCopy(const FCompactMaps& CompactMaps, ParentType* ParentIn) const
    {
        TDynamicAttributeBase* Copy = MakeCopy(ParentIn);
        Copy->CompactInPlace(CompactMaps);
        return Copy;
    }
 
    virtual void CompactInPlace(const FCompactMaps& CompactMaps) = 0;
    
    virtual void Reparent(ParentType* NewParent) = 0;
 
    virtual bool CopyThroughMapping(const TDynamicAttributeBase* Source, const FMeshIndexMappings& Mapping) = 0;
 
    virtual bool Append(const TDynamicAttributeBase& Source, const FDynamicMesh3::FAppendInfo& AppendInfo) = 0;
 
    virtual void AppendDefaulted(const FDynamicMesh3::FAppendInfo& AppendInfo) = 0;
 
    virtual bool CopyOut(int RawID, void* Buffer, int BufferSize) const = 0;
 
    virtual bool CopyIn(int RawID, void* Buffer, int BufferSize) = 0;
 
    virtual void OnNewVertex(int VertexID, bool bInserted)
    {
    }
 
    virtual void OnRemoveVertex(int VertexID)
    {
    }
 
    virtual void OnNewTriangle(int TriangleID, bool bInserted)
    {
    }
 
    virtual void OnRemoveTriangle(int TriangleID)
    {
    }
 
    virtual void OnReverseTriOrientation(int TriangleID)
    {
    }
 
    virtual bool CheckValidity(bool bAllowNonmanifold, EValidityCheckFailMode FailMode) const
    {
        // default impl just doesn't check anything; override with any useful sanity checks
        return true;
    }
 
 
    virtual TUniquePtr<TDynamicAttributeChangeBase<ParentType>> NewBlankChange() const = 0;
 
 
 
    virtual void OnSplitEdge(const DynamicMeshInfo::FEdgeSplitInfo& SplitInfo)
    {
    }
 
    virtual void OnFlipEdge(const DynamicMeshInfo::FEdgeFlipInfo& FlipInfo)
    {
    }
 
    virtual void OnCollapseEdge(const DynamicMeshInfo::FEdgeCollapseInfo& CollapseInfo)
    {
    }
 
    virtual void OnPokeTriangle(const DynamicMeshInfo::FPokeTriangleInfo& PokeInfo)
    {
    }
 
    virtual void OnMergeEdges(const DynamicMeshInfo::FMergeEdgesInfo& MergeInfo)
    {
    }
 
    virtual void OnMergeVertices(const DynamicMeshInfo::FMergeVerticesInfo& MergeInfo)
    {
    }
 
    virtual void OnSplitVertex(const DynamicMeshInfo::FVertexSplitInfo& SplitInfo, const TArrayView<const int>& TrianglesToUpdate)
    {
    }
 
    friend FArchive& operator<<(FArchive& Ar, TDynamicAttributeBase<ParentType>& Attr)
    {
        Attr.Serialize(Ar);
        return Ar;
    }
 
    void Serialize(FArchive& Ar)
    {
        Ar.UsingCustomVersion(FUE5MainStreamObjectVersion::GUID);
        if (!Ar.IsLoading() || Ar.CustomVer(FUE5MainStreamObjectVersion::GUID) >= FUE5MainStreamObjectVersion::DynamicMeshAttributesWeightMapsAndNames)
        {
            FNameAsStringProxyArchive ProxyArchive(Ar);
            ProxyArchive << Name;
        }
    }
 
    virtual SIZE_T GetByteCount() const { return 0; }
 
protected:
 
    virtual void CopyParentClassData(const TDynamicAttributeBase<ParentType>& Other)
    {
        Name = Other.Name;
    }
};
 
 
typedef TDynamicAttributeBase<FDynamicMesh3> FDynamicMeshAttributeBase;
 
 
template<typename ParentType>
class TDynamicAttributeSetBase
{
protected:
    // not managed by the base class; we should be able to register any attributes here that we want to be automatically updated
    TArray<TDynamicAttributeBase<ParentType>*> RegisteredAttributes;
 
    void RegisterExternalAttribute(TDynamicAttributeBase<ParentType>* Attribute)
    {
        RegisteredAttributes.Add(Attribute);
    }
 
    void UnregisterExternalAttribute(TDynamicAttributeBase<ParentType>* Attribute)
    {
        RegisteredAttributes.Remove(Attribute);
    }
 
    void ResetRegisteredAttributes()
    {
        RegisteredAttributes.Reset();
    }
 
public:
    virtual ~TDynamicAttributeSetBase()
    {
    }
 
    int NumRegisteredAttributes() const
    {
        return RegisteredAttributes.Num();
    }
 
    TDynamicAttributeBase<ParentType>* GetRegisteredAttribute(int Idx) const
    {
        return RegisteredAttributes[Idx];
    }
 
    // These functions are called by the FDynamicMesh3 to update the various
    // attributes when the parent mesh topology has been modified.
    virtual void OnNewTriangle(int TriangleID, bool bInserted)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnNewTriangle(TriangleID, bInserted);
        }
    }
    virtual void OnNewVertex(int VertexID, bool bInserted)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnNewVertex(VertexID, bInserted);
        }
    }
    virtual void OnRemoveTriangle(int TriangleID)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnRemoveTriangle(TriangleID);
        }
    }
    virtual void OnRemoveVertex(int VertexID)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnRemoveVertex(VertexID);
        }
    }
    virtual void OnReverseTriOrientation(int TriangleID)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnReverseTriOrientation(TriangleID);
        }
    }
 
    virtual bool CheckValidity(bool bAllowNonmanifold, EValidityCheckFailMode FailMode) const
    {
        bool bValid = true;
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            bValid = A->CheckValidity(bAllowNonmanifold, FailMode) && bValid;
        }
        return bValid;
    }
 
 
    // mesh-specific on* functions; may be split out
public:
 
    virtual void OnSplitEdge(const DynamicMeshInfo::FEdgeSplitInfo& SplitInfo)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnSplitEdge(SplitInfo);
        }
    }
    virtual void OnFlipEdge(const DynamicMeshInfo::FEdgeFlipInfo& FlipInfo)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnFlipEdge(FlipInfo);
        }
    }
    virtual void OnCollapseEdge(const DynamicMeshInfo::FEdgeCollapseInfo& CollapseInfo)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnCollapseEdge(CollapseInfo);
        }
    }
    virtual void OnPokeTriangle(const DynamicMeshInfo::FPokeTriangleInfo& PokeInfo)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnPokeTriangle(PokeInfo);
        }
    }
    virtual void OnMergeEdges(const DynamicMeshInfo::FMergeEdgesInfo& MergeInfo)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnMergeEdges(MergeInfo);
        }
    }
    virtual void OnMergeVertices(const DynamicMeshInfo::FMergeVerticesInfo& MergeInfo)
    {
        if (!ensureMsgf(!MergeInfo.EdgeCollapseInfo.IsSet(), TEXT("Vertex merge that resolves as edge collapse "
            "is expected to have called OnCollapseEdge, not OnMergeVertices.")))
        {
            OnCollapseEdge(MergeInfo.EdgeCollapseInfo.GetValue());
            return;
        }
        if (!ensureMsgf(!MergeInfo.MergeEdgesInfo.IsSet(), TEXT("Vertex merge that resolves as edge merge "
            "is expected to have called OnMergeEdges, not OnMergeVertices.")))
        {
            OnMergeEdges(MergeInfo.MergeEdgesInfo.GetValue());
            return;
        }
 
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnMergeVertices(MergeInfo);
        }
    }
    virtual void OnSplitVertex(const DynamicMeshInfo::FVertexSplitInfo& SplitInfo, const TArrayView<const int>& TrianglesToUpdate)
    {
        for (TDynamicAttributeBase<ParentType>* A : RegisteredAttributes)
        {
            A->OnSplitVertex(SplitInfo, TrianglesToUpdate);
        }
    }
};
 
typedef TDynamicAttributeSetBase<FDynamicMesh3> FDynamicMeshAttributeSetBase;
 
} // end namespace UE::Geometry
} // end namespace UE