DynamicMeshAttributeSet.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/IndirectArray.h"
#include "Containers/Map.h"
#include "DynamicMesh/DynamicAttribute.h"
#include "DynamicMesh/DynamicMeshOverlay.h"
#include "DynamicMesh/DynamicMeshTriangleAttribute.h"
#include "DynamicMesh/DynamicVertexAttribute.h"
#include "DynamicMesh/DynamicMeshSculptLayers.h"
#include "GeometryTypes.h"
#include "HAL/PlatformCrt.h"
#include "InfoTypes.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector2D.h"
#include "Math/Vector4.h"
#include "Templates/UniquePtr.h"
#include "UObject/NameTypes.h"
#include "Util/DynamicVector.h"
 
class FArchive;
namespace DynamicMeshInfo { struct FEdgeCollapseInfo; }
namespace DynamicMeshInfo { struct FEdgeFlipInfo; }
namespace DynamicMeshInfo { struct FEdgeSplitInfo; }
namespace DynamicMeshInfo { struct FMergeEdgesInfo; }
namespace DynamicMeshInfo { struct FPokeTriangleInfo; }
namespace DynamicMeshInfo { struct FVertexSplitInfo; }
 
namespace UE
{
namespace Geometry
{
class FCompactMaps;
class FDynamicMesh3;
 
typedef TDynamicMeshVectorOverlay<float, 2, FVector2f> FDynamicMeshUVOverlay;
typedef TDynamicMeshVectorOverlay<float, 3, FVector3f> FDynamicMeshNormalOverlay;
typedef TDynamicMeshVectorOverlay<float, 4, FVector4f> FDynamicMeshColorOverlay;
typedef TDynamicMeshScalarTriangleAttribute<int32> FDynamicMeshMaterialAttribute;
 
typedef TDynamicMeshScalarTriangleAttribute<int32> FDynamicMeshPolygroupAttribute;
 
typedef TDynamicMeshVertexAttribute<float, 1> FDynamicMeshWeightAttribute;
 
typedef TDynamicMeshVertexAttribute<float, 3> FDynamicMeshMorphTargetAttribute;
 
template<typename ParentType>
class TDynamicVertexSkinWeightsAttribute;
 
using FDynamicMeshVertexSkinWeightsAttribute = TDynamicVertexSkinWeightsAttribute<FDynamicMesh3>;
    
template<typename ParentType, typename AttribValueType>
class TDynamicBoneAttributeBase;
 
using FDynamicMeshBoneNameAttribute = TDynamicBoneAttributeBase<FDynamicMesh3, FName>;
using FDynamicMeshBoneParentIndexAttribute = TDynamicBoneAttributeBase<FDynamicMesh3, int32>;
using FDynamicMeshBoneColorAttribute = TDynamicBoneAttributeBase<FDynamicMesh3, FVector4f>;
using FDynamicMeshBonePoseAttribute = TDynamicBoneAttributeBase<FDynamicMesh3, FTransform>;
 
 
class FDynamicMeshAttributeSet : public FDynamicMeshAttributeSetBase
{
public:
    GEOMETRYCORE_API FDynamicMeshAttributeSet(FDynamicMesh3* Mesh);
 
    GEOMETRYCORE_API FDynamicMeshAttributeSet(FDynamicMesh3* Mesh, int32 NumUVLayers, int32 NumNormalLayers);
 
    GEOMETRYCORE_API virtual ~FDynamicMeshAttributeSet() override;
 
    GEOMETRYCORE_API void Copy(const FDynamicMeshAttributeSet& Copy);
 
    GEOMETRYCORE_API bool IsCompact();
 
    GEOMETRYCORE_API void CompactCopy(const FCompactMaps& CompactMaps, const FDynamicMeshAttributeSet& Copy);
 
    GEOMETRYCORE_API void CompactInPlace(const FCompactMaps& CompactMaps);
 
 
    GEOMETRYCORE_API void SplitAllBowties(bool bParallel = true);
 
 
    GEOMETRYCORE_API void EnableMatchingAttributes(const FDynamicMeshAttributeSet& ToMatch, bool bClearExisting = true, bool bDiscardExtraAttributes = false);
 
    const FDynamicMesh3* GetParentMesh() const { return ParentMesh; }
    FDynamicMesh3* GetParentMesh() { return ParentMesh; }
 
private:
    GEOMETRYCORE_API void Reparent(FDynamicMesh3* NewParent);
 
public:
 
    GEOMETRYCORE_API virtual bool IsSeamEdge(int EdgeID) const;
 
    GEOMETRYCORE_API virtual bool IsSeamEndEdge(int EdgeID) const;
 
    UE_DEPRECATED(5.3, "Please instead call the 4 argument version of IsSeamEdge, which distinguishes between tangent and normal seam edges.")
    GEOMETRYCORE_API virtual bool IsSeamEdge(int EdgeID, bool& bIsUVSeamOut, bool& bIsNormalSeamOut, bool& bIsColorSeamOut) const;
 
    GEOMETRYCORE_API virtual bool IsSeamEdge(int EdgeID, bool& bIsUVSeamOut, bool& bIsNormalSeamOut, bool& bIsColorSeamOut, bool& bIsTangentSeamOut) const;
 
    GEOMETRYCORE_API virtual bool IsSeamVertex(int VertexID, bool bBoundaryIsSeam = true) const;
 
    GEOMETRYCORE_API virtual bool IsSeamIntersectionVertex(int32 VertexID) const;
 
    GEOMETRYCORE_API virtual bool IsMaterialBoundaryEdge(int EdgeID) const;
 
    //
    // UV Layers 
    //
 
    virtual int NumUVLayers() const
    {
        return UVLayers.Num();
    }
 
    GEOMETRYCORE_API virtual void SetNumUVLayers(int Num);
 
    FDynamicMeshUVOverlay* GetUVLayer(int Index)
    {
        if (Index < UVLayers.Num() && Index > -1)
        { 
            return &UVLayers[Index];
        }
        return nullptr;
    }
 
    const FDynamicMeshUVOverlay* GetUVLayer(int Index) const
    {
        if (Index < UVLayers.Num() && Index > -1)
        {
            return &UVLayers[Index];
        }
        return nullptr;
    }
 
    FDynamicMeshUVOverlay* PrimaryUV()
    {
        return GetUVLayer(0);
    }
    const FDynamicMeshUVOverlay* PrimaryUV() const
    {
        return GetUVLayer(0);
    }
 
 
    //
    // Normal Layers 
    //
 
    virtual int NumNormalLayers() const
    {
        return NormalLayers.Num();
    }
 
    GEOMETRYCORE_API virtual void SetNumNormalLayers(int Num);
 
    GEOMETRYCORE_API void EnableTangents();
 
    GEOMETRYCORE_API void DisableTangents();
 
    FDynamicMeshNormalOverlay* GetNormalLayer(int Index)
    {
        if (Index < NormalLayers.Num() && Index > -1)
        { 
            return &NormalLayers[Index];
        }
        return nullptr;
    }
 
    const FDynamicMeshNormalOverlay* GetNormalLayer(int Index) const
    {
        if (Index < NormalLayers.Num() && Index > -1)
        {
            return &NormalLayers[Index];
        }
        return nullptr;
    }
 
 
    FDynamicMeshNormalOverlay* PrimaryNormals()
    {
        return GetNormalLayer(0);
    }
    const FDynamicMeshNormalOverlay* PrimaryNormals() const
    {
        return GetNormalLayer(0);
    }
    FDynamicMeshNormalOverlay* PrimaryTangents()
    {
        return GetNormalLayer(1);
    }
    const FDynamicMeshNormalOverlay* PrimaryTangents() const 
    {
        return GetNormalLayer(1);
    }
    FDynamicMeshNormalOverlay* PrimaryBiTangents()
    {
        return GetNormalLayer(2);
    }
    const FDynamicMeshNormalOverlay* PrimaryBiTangents() const
    {
        return GetNormalLayer(2);
    }
 
    bool HasTangentSpace() const
    {
        return (PrimaryNormals() != nullptr && PrimaryTangents()  != nullptr && PrimaryBiTangents() != nullptr);
    }
 
    bool HasPrimaryColors() const
    {
        return !!ColorLayer;
    }
 
    FDynamicMeshColorOverlay* PrimaryColors()
    {
        return ColorLayer.Get();
    }
 
    const FDynamicMeshColorOverlay* PrimaryColors() const
    {
        return ColorLayer.Get();
    }
 
    GEOMETRYCORE_API void EnablePrimaryColors();
    
    GEOMETRYCORE_API void DisablePrimaryColors();
 
    //
    // Polygroup layers
    //
 
    GEOMETRYCORE_API virtual int32 NumPolygroupLayers() const;
 
    GEOMETRYCORE_API virtual void SetNumPolygroupLayers(int32 Num);
 
    GEOMETRYCORE_API FDynamicMeshPolygroupAttribute* GetPolygroupLayer(int Index);
 
    GEOMETRYCORE_API const FDynamicMeshPolygroupAttribute* GetPolygroupLayer(int Index) const;
 
    //
    // Weight layers
    //
 
    GEOMETRYCORE_API virtual int32 NumWeightLayers() const;
 
    GEOMETRYCORE_API virtual void SetNumWeightLayers(int32 Num);
 
    GEOMETRYCORE_API virtual void RemoveWeightLayer(int32 Index);
 
    GEOMETRYCORE_API FDynamicMeshWeightAttribute* GetWeightLayer(int Index);
 
    GEOMETRYCORE_API const FDynamicMeshWeightAttribute* GetWeightLayer(int Index) const;
 
    GEOMETRYCORE_API void EnableMatchingWeightLayersByNames(const FDynamicMeshAttributeSet* ToMatch, bool bDiscardUnmatched);
 
 
 
    //
    // Per-Triangle Material ID
    //
 
    bool HasMaterialID() const
    {
        return !!MaterialIDAttrib;
    }
 
 
    GEOMETRYCORE_API void EnableMaterialID();
 
    GEOMETRYCORE_API void DisableMaterialID();
 
    FDynamicMeshMaterialAttribute* GetMaterialID()
    {
        return MaterialIDAttrib.Get();
    }
 
    const FDynamicMeshMaterialAttribute* GetMaterialID() const
    {
        return MaterialIDAttrib.Get();
    }
 
    GEOMETRYCORE_API void AttachSkinWeightsAttribute(FName InProfileName, FDynamicMeshVertexSkinWeightsAttribute* InAttribute);
 
    GEOMETRYCORE_API void RemoveSkinWeightsAttribute(FName InProfileName);
 
    GEOMETRYCORE_API void RemoveAllSkinWeightsAttributes();
 
    bool HasSkinWeightsAttribute(FName InProfileName) const
    {
        return SkinWeightAttributes.Contains(InProfileName);
    }
 
    FDynamicMeshVertexSkinWeightsAttribute *GetSkinWeightsAttribute(FName InProfileName) const
    {
        if (SkinWeightAttributes.Contains(InProfileName))
        {
            return SkinWeightAttributes[InProfileName].Get();
        }
        else
        {
            return nullptr;
        }
    }
    
    const TMap<FName, TUniquePtr<FDynamicMeshVertexSkinWeightsAttribute>>& GetSkinWeightsAttributes() const
    {
        return SkinWeightAttributes;
    }
 
    GEOMETRYCORE_API void AttachMorphTargetAttribute(FName InMorphTargetName, FDynamicMeshMorphTargetAttribute* InAttribute);
 
    GEOMETRYCORE_API void RemoveMorphTargetAttribute(FName InMorphTargetName);
    
    GEOMETRYCORE_API void RemoveAllMorphTargetAttributes();
 
    bool HasMorphTargetAttribute(FName InMorphTargetName) const
    {
        return MorphTargetAttributes.Contains(InMorphTargetName);
    }
 
    FDynamicMeshMorphTargetAttribute* GetMorphTargetAttribute(FName InMorphTargetName) const
    {
        if (const TUniquePtr<FDynamicMeshMorphTargetAttribute>* AttributePtr = MorphTargetAttributes.Find(InMorphTargetName))
        {
            return AttributePtr->Get();
        }
        else
        {
            return nullptr;
        }
    }
    
    const TMap<FName, TUniquePtr<FDynamicMeshMorphTargetAttribute>>& GetMorphTargetAttributes() const
    {
        return MorphTargetAttributes;
    }
 
    //
    // Bone Attributes
    //
 
    GEOMETRYCORE_API void CopyBoneAttributes(const FDynamicMeshAttributeSet& Copy);
 
    GEOMETRYCORE_API void CopyBoneAttributesWithRemapping(const FDynamicMeshAttributeSet& Copy, const TMap<FName, FName>& BoneHierarchy); 
    
    GEOMETRYCORE_API void EnableMatchingBoneAttributes(const FDynamicMeshAttributeSet& ToMatch, bool bClearExisting, bool bDiscardExtraAttributes);
 
    GEOMETRYCORE_API bool IsSameBoneAttributesAs(const FDynamicMeshAttributeSet& Other) const;
 
    GEOMETRYCORE_API bool CheckBoneValidity(EValidityCheckFailMode FailMode) const;
 
    
    GEOMETRYCORE_API bool AppendBonesUnique(const FDynamicMeshAttributeSet& Other);
 
    GEOMETRYCORE_API void EnableBones(const int InBonesNum);
 
    GEOMETRYCORE_API void DisableBones();
    
    GEOMETRYCORE_API int32 GetNumBones() const;
 
    bool HasBones() const 
    { 
        return !!BoneNameAttrib; 
    }
 
    FDynamicMeshBoneNameAttribute* GetBoneNames()
    {
        return BoneNameAttrib.Get();
    }
 
    const FDynamicMeshBoneNameAttribute* GetBoneNames() const
    {
        return BoneNameAttrib.Get();
    }
    
    FDynamicMeshBoneParentIndexAttribute* GetBoneParentIndices()
    {
        return BoneParentIndexAttrib.Get();
    }
 
    const FDynamicMeshBoneParentIndexAttribute* GetBoneParentIndices() const
    {
        return BoneParentIndexAttrib.Get();
    }
 
    FDynamicMeshBonePoseAttribute* GetBonePoses()
    {
        return BonePoseAttrib.Get();
    }
 
    const FDynamicMeshBonePoseAttribute* GetBonePoses() const
    {
        return BonePoseAttrib.Get();
    }
 
    FDynamicMeshBoneColorAttribute* GetBoneColors()
    {
        return BoneColorAttrib.Get();
    }
 
    const FDynamicMeshBoneColorAttribute* GetBoneColors() const
    {
        return BoneColorAttrib.Get();
    }
 
    const FDynamicMeshSculptLayers* GetSculptLayers() const
    {
        return &SculptLayers;
    }
    
    FDynamicMeshSculptLayers* GetSculptLayers()
    {
        return &SculptLayers;
    }
 
    // Number of sculpt layers enabled on the mesh
    inline int32 NumSculptLayers() const
    {
        return SculptLayers.Layers.Num();
    }
 
    // Enable sculpt layers on the mesh, if they are not already enabled.
    // @param MinLayers Number of layers to enabled. If more layers already exist, no layers will be removed.
    GEOMETRYCORE_API void EnableSculptLayers(int32 MinLayers);
 
    // Discard sculpt layer data from the mesh.
    GEOMETRYCORE_API void DiscardSculptLayers();
 
 
    // Attach a new attribute (and transfer ownership of it to the attribute set)
    void AttachAttribute(FName AttribName, FDynamicMeshAttributeBase* Attribute)
    {
        if (GenericAttributes.Contains(AttribName))
        {
            UnregisterExternalAttribute(GenericAttributes[AttribName].Get());
        }
        GenericAttributes.Add(AttribName, TUniquePtr<FDynamicMeshAttributeBase>(Attribute));
        RegisterExternalAttribute(Attribute);
    }
 
    void RemoveAttribute(FName AttribName)
    {
        if (GenericAttributes.Contains(AttribName))
        {
            UnregisterExternalAttribute(GenericAttributes[AttribName].Get());
            GenericAttributes.Remove(AttribName);
        }
    }
 
    FDynamicMeshAttributeBase* GetAttachedAttribute(FName AttribName)
    {
        return GenericAttributes[AttribName].Get();
    }
 
    const FDynamicMeshAttributeBase* GetAttachedAttribute(FName AttribName) const
    {
        return GenericAttributes[AttribName].Get();
    }
    int NumAttachedAttributes() const
    {
        return GenericAttributes.Num();
    }
 
    bool HasAttachedAttribute(FName AttribName) const
    {
        return GenericAttributes.Contains(AttribName);
    }
 
    const TMap<FName, TUniquePtr<FDynamicMeshAttributeBase>>& GetAttachedAttributes() const
    {
        return GenericAttributes;
    }
 
    GEOMETRYCORE_API bool IsSameAs(const FDynamicMeshAttributeSet& Other, bool bIgnoreDataLayout) const;
 
    friend FArchive& operator<<(FArchive& Ar, FDynamicMeshAttributeSet& Set)
    {
        Set.Serialize(Ar, nullptr, false);
        return Ar;
    }
 
    GEOMETRYCORE_API void Serialize(FArchive& Ar, const FCompactMaps* CompactMaps, bool bUseCompression);
 
    GEOMETRYCORE_API SIZE_T GetByteCount() const;
 
protected:
    FDynamicMesh3* ParentMesh;
    
 
    TIndirectArray<FDynamicMeshUVOverlay> UVLayers;
    TIndirectArray<FDynamicMeshNormalOverlay> NormalLayers;
    TUniquePtr<FDynamicMeshColorOverlay> ColorLayer;
 
    TUniquePtr<FDynamicMeshMaterialAttribute> MaterialIDAttrib;
 
    TIndirectArray<FDynamicMeshWeightAttribute> WeightLayers;
    TIndirectArray<FDynamicMeshPolygroupAttribute> PolygroupLayers;
 
    using SkinWeightAttributesMap = TMap<FName, TUniquePtr<FDynamicMeshVertexSkinWeightsAttribute>>;
    SkinWeightAttributesMap SkinWeightAttributes;
 
    using MorphTargetAttributesMap = TMap<FName, TUniquePtr<FDynamicMeshMorphTargetAttribute>>;
    MorphTargetAttributesMap MorphTargetAttributes;
 
    // Bone attributes
    TUniquePtr<FDynamicMeshBoneNameAttribute> BoneNameAttrib;
    TUniquePtr<FDynamicMeshBoneParentIndexAttribute> BoneParentIndexAttrib;
    TUniquePtr<FDynamicMeshBonePoseAttribute> BonePoseAttrib;
    TUniquePtr<FDynamicMeshBoneColorAttribute> BoneColorAttrib;
 
    using GenericAttributesMap = TMap<FName, TUniquePtr<FDynamicMeshAttributeBase>>;
    GenericAttributesMap GenericAttributes;
 
private:
 
    // Class to manage sculpt layer data, separated out mainly for clearer organization
    FDynamicMeshSculptLayers SculptLayers;
    friend class FDynamicMeshSculptLayers;
    
    
protected:
    friend class FDynamicMesh3;
 
    void Initialize(int MaxVertexID, int MaxTriangleID)
    {
        for (FDynamicMeshUVOverlay& UVLayer : UVLayers)
        {
            UVLayer.InitializeTriangles(MaxTriangleID);
        }
        for (FDynamicMeshNormalOverlay& NormalLayer : NormalLayers)
        {
            NormalLayer.InitializeTriangles(MaxTriangleID);
        }
    }
 
    // These functions are called by the FDynamicMesh3 to update the various
    // attributes when the parent mesh topology has been modified.
    // TODO: would it be better to register all the overlays and attributes with the base set and not overload these?  maybe!
    GEOMETRYCORE_API virtual void OnNewTriangle(int TriangleID, bool bInserted);
    GEOMETRYCORE_API virtual void OnNewVertex(int VertexID, bool bInserted);
    GEOMETRYCORE_API virtual void OnRemoveTriangle(int TriangleID);
    GEOMETRYCORE_API virtual void OnRemoveVertex(int VertexID);
    GEOMETRYCORE_API virtual void OnReverseTriOrientation(int TriangleID);
    GEOMETRYCORE_API virtual void OnSplitEdge(const DynamicMeshInfo::FEdgeSplitInfo & splitInfo);
    GEOMETRYCORE_API virtual void OnFlipEdge(const DynamicMeshInfo::FEdgeFlipInfo & flipInfo);
    GEOMETRYCORE_API virtual void OnCollapseEdge(const DynamicMeshInfo::FEdgeCollapseInfo & collapseInfo);
    GEOMETRYCORE_API virtual void OnPokeTriangle(const DynamicMeshInfo::FPokeTriangleInfo & pokeInfo);
    GEOMETRYCORE_API virtual void OnMergeEdges(const DynamicMeshInfo::FMergeEdgesInfo & mergeInfo);
    GEOMETRYCORE_API virtual void OnMergeVertices(const DynamicMeshInfo::FMergeVerticesInfo& mergeInfo);
    GEOMETRYCORE_API virtual void OnSplitVertex(const DynamicMeshInfo::FVertexSplitInfo& SplitInfo, const TArrayView<const int>& TrianglesToUpdate);
 
    GEOMETRYCORE_API virtual bool CheckValidity(bool bAllowNonmanifold, EValidityCheckFailMode FailMode) const;
 
private:
 
    // Called by FDynamicMesh3 during a mesh append, to append a corresponding attribute set
    void Append(const FDynamicMeshAttributeSet& ToAppend, const FDynamicMesh3::FAppendInfo& AppendInfo);
    // Called by FDynamicMesh3 during a mesh append, to defaulted attributes when the ToAppend mesh did not have an attribute set
    void AppendDefaulted(const FDynamicMesh3::FAppendInfo& AppendInfo);
};
 
 
 
} // end namespace UE::Geometry
} // end namespace UE