DynamicMeshChangeTracker.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/BitArray.h"
#include "CoreTypes.h"
#include "DynamicMesh/DynamicAttribute.h"
#include "DynamicMesh/DynamicMesh3.h"
#include "DynamicMesh/DynamicMeshAttributeSet.h"
#include "DynamicMesh/DynamicMeshOverlay.h"
#include "DynamicMesh/DynamicMeshTriangleAttribute.h"
#include "DynamicMesh/InfoTypes.h"
#include "GeometryTypes.h"
#include "HAL/PlatformCrt.h"
#include "IndexTypes.h"
#include "Misc/Optional.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
 
 
//
// Implementation of mesh change tracking for FDynamicMesh3.
// 
// The top-level class is FDynamicMeshChangeTracker, found at the bottom of this file.
// You create an instance of this and then call BeginChange(), then call SaveVertex()/SaveTriangle()
// before you make modifications to a vertex/triangle, and then call EndChange() at the end.
// This function emits a FDynamicMeshChange instance, and you can call Apply() to apply/revert it.
// So this is the object you would store in a higher-level undo/redo record, for example.
// 
// Attribute overlays make everything more complicated of course. Handling of these
// follows a similar structure - the MeshChangeTracker creates a FDynamicMeshAttributeSetChangeTracker,
// which in turn creates a TDynamicMeshAttributeChange for each UV and Normal overlay
// (grouped together in a FDynamicMeshAttributeChangeSet). However you don't have to explicitly
// do anything to get Attribute support, if the initial Mesh had attributes, then
// this all happens automatically, and the attribute changes get attached to the FDynamicMeshChange.
// 
// @todo Currently the attribute support is hardcoded for UV (2-float) and Normal (3-float) overlays.
// Perhaps it would be possible to make this more flexible to avoid hardcoding these?
// Very little of the code depends on the element size or type.
// 
// 
 
namespace UE
{
namespace Geometry
{
 
 
template<typename RealType, int ElementSize>
class TDynamicMeshAttributeChange
{
public:
    GEOMETRYCORE_API void SaveInitialElement(const TDynamicMeshOverlay<RealType,ElementSize>* Overlay, int ElementID);
    GEOMETRYCORE_API void SaveInitialTriangle(const TDynamicMeshOverlay<RealType,ElementSize>* Overlay, int TriangleID);
 
    GEOMETRYCORE_API void StoreFinalElement(const TDynamicMeshOverlay<RealType, ElementSize>* Overlay, int ElementID);
    GEOMETRYCORE_API void StoreFinalTriangle(const TDynamicMeshOverlay<RealType, ElementSize>* Overlay, int TriangleID);
 
    GEOMETRYCORE_API bool Apply(TDynamicMeshOverlay<RealType, ElementSize>* Overlay, bool bRevert) const;
 
protected:
    struct FChangeElement
    {
        int ElementID;
        int DataIndex;
        int ParentVertexID;
    };
 
    struct FChangeTriangle
    {
        int TriangleID;
        FIndex3i Elements;
    };
 
    TArray<FChangeElement> OldElements;
    TArray<RealType> OldElementData;
    TArray<FChangeTriangle> OldTriangles;
 
    TArray<FChangeElement> NewElements;
    TArray<RealType> NewElementData;
    TArray<FChangeTriangle> NewTriangles;
 
    GEOMETRYCORE_API void ApplyReplaceChange(TDynamicMeshOverlay<RealType,ElementSize>* Overlay,
        const TArray<FChangeTriangle>& RemoveTris,
        const TArray<FChangeElement>& InsertElements,
        const TArray<RealType>& InsertElementData,
        const TArray<FChangeTriangle>& InsertTris) const;
};
 
typedef TDynamicMeshAttributeChange<float,2> FDynamicMeshUVChange;
typedef TDynamicMeshAttributeChange<float,3> FDynamicMeshNormalChange;
typedef TDynamicMeshAttributeChange<float, 4> FDynamicMeshColorChange;
typedef FDynamicMeshTriangleAttributeChange<int32,1> FDynamicMeshTriGroupChange;
 
typedef TDynamicMeshAttributeChange<float, 1> FDynamicMeshWeightChange;
 
class FDynamicMeshAttributeChangeSet
{
public:
    UE_NONCOPYABLE(FDynamicMeshAttributeChangeSet);
    FDynamicMeshAttributeChangeSet() = default;
 
    TArray<FDynamicMeshUVChange> UVChanges;
    TArray<FDynamicMeshNormalChange> NormalChanges;
    TOptional<FDynamicMeshColorChange> ColorChange;
    TOptional<FDynamicMeshTriGroupChange> MaterialIDAttribChange;
    TArray<FDynamicMeshTriGroupChange> PolygroupChanges;
 
    TArray<TUniquePtr<FDynamicMeshAttributeChangeBase>> WeightChanges;
    TArray<TUniquePtr<FDynamicMeshAttributeChangeBase>> RegisteredAttributeChanges;
 
    GEOMETRYCORE_API bool Apply(FDynamicMeshAttributeSet* Attributes, bool bRevert) const;
};
 
 
class FDynamicMeshChange
{
public:
    GEOMETRYCORE_API ~FDynamicMeshChange();
 
    GEOMETRYCORE_API void SaveInitialVertex(const FDynamicMesh3* Mesh, int VertexID);
    GEOMETRYCORE_API void SaveInitialTriangle(const FDynamicMesh3* Mesh, int TriangleID);
 
    GEOMETRYCORE_API void StoreFinalVertex(const FDynamicMesh3* Mesh, int VertexID);
    GEOMETRYCORE_API void StoreFinalTriangle(const FDynamicMesh3* Mesh, int TriangleID);
 
    void AttachAttributeChanges(TUniquePtr<FDynamicMeshAttributeChangeSet> AttribChanges)
    {
        this->AttributeChanges = MoveTemp(AttribChanges);
    }
 
    GEOMETRYCORE_API bool Apply(FDynamicMesh3* Mesh, bool bRevert) const;
 
    GEOMETRYCORE_API void VerifySaveState() const;
 
    GEOMETRYCORE_API bool HasSavedVertex(int VertexID);
 
    GEOMETRYCORE_API void GetSavedTriangleList(TArray<int>& TrianglesOut, bool bInitial) const;
 
    GEOMETRYCORE_API void GetAffectedVertices(TArray<int>& VerticesOut, bool bRevert) const;
 
    GEOMETRYCORE_API void CheckValidity(EValidityCheckFailMode FailMode = EValidityCheckFailMode::Check) const;
 
protected:
 
    struct FChangeVertex
    {
        int VertexID;
        FVertexInfo Info;
    };
 
    struct FChangeTriangle
    {
        int TriangleID;
        FIndex3i Vertices;
        FIndex3i Edges;
        int GroupID;
    };
 
    TArray<FChangeVertex> OldVertices;
    TArray<FChangeTriangle> OldTriangles;
 
    TArray<FChangeVertex> NewVertices;
    TArray<FChangeTriangle> NewTriangles;
 
    TUniquePtr<FDynamicMeshAttributeChangeSet> AttributeChanges;
 
    GEOMETRYCORE_API void ApplyReplaceChange(FDynamicMesh3* Mesh,
        const TArray<FChangeTriangle>& RemoveTris,
        const TArray<FChangeVertex>& InsertVerts,
        const TArray<FChangeTriangle>& InsertTris) const;
 
};
 
 
 
 
 
 
 
class FDynamicMeshAttributeSetChangeTracker
{
public:
    GEOMETRYCORE_API explicit FDynamicMeshAttributeSetChangeTracker(const FDynamicMeshAttributeSet* Attribs);
 
    GEOMETRYCORE_API void BeginChange();
    GEOMETRYCORE_API TUniquePtr<FDynamicMeshAttributeChangeSet> EndChange();
 
    GEOMETRYCORE_API void SaveInitialTriangle(int TriangleID);
 
    GEOMETRYCORE_API void StoreAllFinalTriangles(const TArray<int>& TriangleIDs);
 
    GEOMETRYCORE_API void SaveInitialVertex(int VertexID);
 
    UE_DEPRECATED(5.6, "Use the version of this method that takes a TSet instead")
    void StoreAllFinalVertices(const TArray<int>& VertexIDs)
    {
        ensure(false);
    }
    GEOMETRYCORE_API void StoreAllFinalVertices(const TSet<int>& VertexIDs);
 
 
protected:
    const FDynamicMeshAttributeSet* Attribs = nullptr;
 
    FDynamicMeshAttributeChangeSet* Change = nullptr;
 
    struct FElementState
    {
        int MaxElementID;
        TBitArray<> StartElements;
        TBitArray<> ChangedElements;
    };
    TArray<FElementState> UVStates;
    TArray<FElementState> NormalStates;
    FElementState ColorState;
 
    template<typename AttribOverlayType, typename AttribChangeType>
    void SaveElement(int ElementID, FElementState& State, const AttribOverlayType* Overlay, AttribChangeType& ChangeIn)
    {
        if (ElementID < State.MaxElementID && State.ChangedElements[ElementID] == false && State.StartElements[ElementID] == true)
        {
            ChangeIn.SaveInitialElement(Overlay, ElementID);
            State.ChangedElements[ElementID] = true;
        }
    }
 
};
 
 
 
 
 
 
 
 
 
class FDynamicMeshChangeTracker
{
public:
    GEOMETRYCORE_API explicit FDynamicMeshChangeTracker(const FDynamicMesh3* Mesh);
    GEOMETRYCORE_API ~FDynamicMeshChangeTracker();
 
    GEOMETRYCORE_API void BeginChange();
    GEOMETRYCORE_API TUniquePtr<FDynamicMeshChange> EndChange();
 
    GEOMETRYCORE_API void SaveTriangle(int32 TriangleID, bool bSaveVertices);
 
    inline void SaveEdge(int32 EdgeID, bool bVertices);
 
    template<typename EnumerableType>
    void SaveTriangles(EnumerableType TriangleIDs, bool bSaveVertices);
 
    template<typename EnumerableType>
    void SaveTrianglesAndNeighbourTris(EnumerableType TriangleIDs, bool bSaveVertices);
 
    inline void SaveVertexOneRingTriangles(int32 VertexID, bool bSaveVertices);
 
    template<typename EnumerableType>
    void SaveVertexOneRingTriangles(EnumerableType VertexIDs, bool bSaveVertices);
 
    GEOMETRYCORE_API void VerifySaveState();
 
protected:
 
    //
    // Currently EndChange() only stores vertices that are part of modified triangles.
    // So calling SaveVertex() independently, on triangles that are not saved, will be lost.
    // (This needs to be fixed)
    //
 
    GEOMETRYCORE_API void SaveVertex(int32 VertexID);
 
    template<typename EnumerableType>
    void SaveVertices(EnumerableType VertexIDs);
 
 
protected:
    const FDynamicMesh3* Mesh = nullptr;
 
    FDynamicMeshAttributeSetChangeTracker* AttribChangeTracker = nullptr;
 
    FDynamicMeshChange* Change = nullptr;
 
    int32 MaxTriangleID;
    TBitArray<> StartTriangles;     // bit is 1 if triangle ID was in initial mesh on BeginChange()
    TBitArray<> ChangedTriangles;   // bit is set to 1 if triangle was in StartTriangles and then had SaveTriangle() called for it
 
    int32 MaxVertexID;
    TBitArray<> StartVertices;      // bit is 1 if vertex ID was in initial mesh on BeginChange()
    TBitArray<> ChangedVertices;    // bit is set to 1 if vertex was in StartVertices and then had SaveVertex() called for it
};
 
 
 
void FDynamicMeshChangeTracker::SaveEdge(int32 EdgeID, bool bVertices)
{
    const FDynamicMesh3::FEdge Edge = Mesh->GetEdge(EdgeID);
    SaveTriangle(Edge.Tri[0], bVertices);
    if (Edge.Tri[1] != FDynamicMesh3::InvalidID)
    {
        SaveTriangle(Edge.Tri[1], bVertices);
    }
}
 
template<typename EnumerableType>
void FDynamicMeshChangeTracker::SaveVertices(EnumerableType VertexIDs)
{
    for (int32 VertexID : VertexIDs)
    {
        SaveVertex(VertexID);
    }
}
 
template<typename EnumerableType>
void FDynamicMeshChangeTracker::SaveTriangles(EnumerableType TriangleIDs, bool bSaveVertices)
{
    for (int32 TriangleID : TriangleIDs)
    {
        SaveTriangle(TriangleID, bSaveVertices);
    }
}
 
 
template<typename EnumerableType>
void FDynamicMeshChangeTracker::SaveTrianglesAndNeighbourTris(EnumerableType TriangleIDs, bool bSaveVertices)
{
    for (int32 TriangleID : TriangleIDs)
    {
        SaveTriangle(TriangleID, bSaveVertices);
 
        FIndex3i TriNbrs = Mesh->GetTriNeighbourTris(TriangleID);
        for (int32 j = 0; j < 3; ++j)
        {
            if (TriNbrs[j] != FDynamicMesh3::InvalidID)
            {
                SaveTriangle(TriNbrs[j], bSaveVertices);
            }
        }
    }
}
 
 
void FDynamicMeshChangeTracker::SaveVertexOneRingTriangles(int32 VertexID, bool bSaveVertices)
{
    Mesh->EnumerateVertexTriangles(VertexID, [this, bSaveVertices](int32 TriangleID)
    {
        SaveTriangle(TriangleID, bSaveVertices);
    });
}
 
template<typename EnumerableType>
void FDynamicMeshChangeTracker::SaveVertexOneRingTriangles(EnumerableType VertexIDs, bool bSaveVertices)
{
    for (int32 VertexID : VertexIDs)
    {
        SaveVertexOneRingTriangles(VertexID, bSaveVertices);
    }
}
 
 
 
} // end namespace UE::Geometry
} // end namespace UE