MeshElementContainer.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 "Containers/ContainerAllocationPolicies.h"
#include "Containers/SparseArray.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "MeshAttributeArray.h"
#include "Misc/AssertionMacros.h"
#include "Serialization/Archive.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
 
 
class FMeshElementContainer
{
public:
    FMeshElementContainer() = default;
    FMeshElementContainer(const FMeshElementContainer&) = default;
    FMeshElementContainer& operator=(const FMeshElementContainer&) = default;
 
    FMeshElementContainer(FMeshElementContainer&& Other)
    {
        BitArray = MoveTemp(Other.BitArray);
        Attributes = MoveTemp(Other.Attributes);
        NumHoles = Other.NumHoles;
        Other.NumHoles = 0;
    }
 
    FMeshElementContainer& operator=(FMeshElementContainer&& Other)
    {
        if (this != &Other)
        {
            BitArray = MoveTemp(Other.BitArray);
            Attributes = MoveTemp(Other.Attributes);
            NumHoles = Other.NumHoles;
            Other.NumHoles = 0;
        }
        return *this;
    }
 
    void Reset(const int32 Elements = 0)
    {
        BitArray.Empty(Elements);
        Attributes.Initialize(0);
        NumHoles = 0;
    }
 
    void Reserve(const int32 Elements) { BitArray.Reserve(Elements); }
 
    int32 Add()
    {
        if (NumHoles > 0)
        {
            // If there are holes, use those up first.
            const int32 Index = BitArray.FindAndSetFirstZeroBit();
            check(Index != INDEX_NONE);
            NumHoles--;
            return Index;
        }
        else
        {
            // Otherwise add a new element, and insert a corresponding attribute slot.
            const int32 Index = BitArray.Add(true);
            Attributes.Insert(Index);
            return Index;
        }
    }
 
    void Insert(const int32 Index)
    {
        checkSlow(Index >= 0);
        if (Index >= BitArray.Num())
        {
            // If the index is beyond the current bit array size, create a new one, padded out with zeroes.
            const int32 FirstNewIndex = BitArray.Num();
            const int32 NumNewHoles = Index - FirstNewIndex;
            BitArray.SetNumUninitialized(Index + 1);
            BitArray.SetRange(FirstNewIndex, NumNewHoles, false);
            BitArray[Index] = true;
            NumHoles += NumNewHoles;
            Attributes.Insert(Index);
        }
        else
        {
            // Can't insert an index over an existing one.
            // If we get here, we assume this is a hole, so decrement the number of holes.
            checkSlow(!BitArray[Index]);
            BitArray[Index] = true;
            NumHoles--;
        }
    }
 
    void Remove(const int32 Index)
    {
        // We can't remove an element which is already a hole.
        checkSlow(BitArray[Index]);
        BitArray[Index] = false;
        NumHoles++;
        Attributes.Remove(Index);
    }
 
    int32 Num() const { return BitArray.Num() - NumHoles; }
 
    int32 GetArraySize() const { return BitArray.Num(); }
 
    int32 GetFirstValidID() const
    {
        return BitArray.Find(true);
    }
 
    bool IsValid(const int32 Index) const
    {
        return Index >= 0 && Index < BitArray.Num() && BitArray[Index];
    }
 
    inline FAttributesSetBase& GetAttributes() { return Attributes; }
    inline const FAttributesSetBase& GetAttributes() const { return Attributes; }
 
    MESHDESCRIPTION_API void Compact(TSparseArray<int32>& OutIndexRemap);
 
    MESHDESCRIPTION_API void Remap(const TSparseArray<int32>& IndexRemap);
 
    friend FArchive& operator<<(FArchive& Ar, FMeshElementContainer& Container)
    {
        Ar << Container.BitArray;
        // We could count the number of holes in the BitArray, but it is quicker for serialization purposes (particularly in transactions) to just store it.
        Ar << Container.NumHoles;
        Ar << Container.Attributes;
        return Ar;
    }
 
    class FElementIDs
    {
    public:
        explicit inline FElementIDs(const TBitArray<>& InArray)
            : Array(InArray)
        {}
 
        class FConstIterator
        {
        public:
            explicit inline FConstIterator(TConstSetBitIterator<>&& It)
                : Iterator(MoveTemp(It))
            {}
 
            inline FConstIterator& operator++()
            {
                ++Iterator;
                return *this;
            }
 
            inline int32 operator*() const
            {
                return Iterator ? Iterator.GetIndex() : INDEX_NONE;
            }
 
            friend inline bool operator==(const FConstIterator& Lhs, const FConstIterator& Rhs)
            {
                return Lhs.Iterator == Rhs.Iterator;
            }
 
            friend inline bool operator!=(const FConstIterator& Lhs, const FConstIterator& Rhs)
            {
                return Lhs.Iterator != Rhs.Iterator;
            }
 
        private:
            TConstSetBitIterator<> Iterator;
        };
 
        inline FConstIterator CreateConstIterator() const
        {
            return FConstIterator(TConstSetBitIterator<>(Array));
        }
 
    public:
        inline FConstIterator begin() const
        {
            return FConstIterator(TConstSetBitIterator<>(Array));
        }
 
        inline FConstIterator end() const
        {
            return FConstIterator(TConstSetBitIterator<>(Array, Array.Num()));
        }
 
    private:
        const TBitArray<>& Array;
    };
 
    FElementIDs inline GetElementIDs() const { return FElementIDs(BitArray); }
 
protected:
    TBitArray<> BitArray;
 
    FAttributesSetBase Attributes;
 
    int32 NumHoles = 0;
};
 
 
template <typename ElementIDType>
class TMeshElementContainer : public FMeshElementContainer
{
public:
    ElementIDType Add()
    {
        return ElementIDType(FMeshElementContainer::Add());
    }
 
    void Insert(const ElementIDType Index)
    {
        FMeshElementContainer::Insert(Index.GetValue());
    }
 
    void Remove(const ElementIDType Index)
    {
        FMeshElementContainer::Remove(Index.GetValue());
    }
 
    ElementIDType GetFirstValidID() const
    {
        return ElementIDType(FMeshElementContainer::GetFirstValidID());
    }
 
    bool IsValid(const ElementIDType Index) const
    {
        return FMeshElementContainer::IsValid(Index.GetValue());
    }
 
    inline TAttributesSet<ElementIDType>& GetAttributes() { return static_cast<TAttributesSet<ElementIDType>&>(Attributes); }
    inline const TAttributesSet<ElementIDType>& GetAttributes() const { return static_cast<const TAttributesSet<ElementIDType>&>(Attributes); }
 
    friend FArchive& operator<<(FArchive& Ar, TMeshElementContainer& Container)
    {
        Ar << static_cast<FMeshElementContainer&>(Container);
        return Ar;
    }
 
    class TElementIDs
    {
    public:
        explicit inline TElementIDs(const TBitArray<>& InArray)
            : Array(InArray)
        {}
 
        class TConstIterator
        {
        public:
            explicit inline TConstIterator(TConstSetBitIterator<>&& It)
                : Iterator(MoveTemp(It))
            {}
 
            inline TConstIterator& operator++()
            {
                ++Iterator;
                return *this;
            }
 
            inline ElementIDType operator*() const
            {
                return ElementIDType{Iterator ? Iterator.GetIndex() : INDEX_NONE};
            }
 
            friend inline bool operator==(const TConstIterator& Lhs, const TConstIterator& Rhs)
            {
                return Lhs.Iterator == Rhs.Iterator;
            }
 
            friend inline bool operator!=(const TConstIterator& Lhs, const TConstIterator& Rhs)
            {
                return Lhs.Iterator != Rhs.Iterator;
            }
 
        private:
            TConstSetBitIterator<> Iterator;
        };
 
        inline TConstIterator CreateConstIterator() const
        {
            return TConstIterator(TConstSetBitIterator<>(Array));
        }
 
    public:
        inline TConstIterator begin() const
        {
            return TConstIterator(TConstSetBitIterator<>(Array));
        }
 
        inline TConstIterator end() const
        {
            return TConstIterator(TConstSetBitIterator<>(Array, Array.Num()));
        }
 
    private:
        const TBitArray<>& Array;
    };
 
    TElementIDs inline GetElementIDs() const { return TElementIDs(BitArray); }
};
 
 
class FMeshElementChannels
{
public:
    explicit FMeshElementChannels(const int32 NumberOfIndices = 1)
    {
        Channels.SetNum(NumberOfIndices);
    }
 
    inline const FMeshElementContainer& Get(const int32 Index = 0) const { return Channels[Index]; }
    inline const FMeshElementContainer& operator[](const int32 Index) const { return Channels[Index]; }
    inline const FMeshElementContainer& operator*() const { return Channels[0]; }
    inline const FMeshElementContainer* operator->() const { return &Channels[0]; }
    inline FMeshElementContainer& Get(const int32 Index = 0) { return Channels[Index]; }
    inline FMeshElementContainer& operator[](const int32 Index) { return Channels[Index]; }
    inline FMeshElementContainer& operator*() { return Channels[0]; }
    inline FMeshElementContainer* operator->() { return &Channels[0]; }
 
    void SetNumChannels(const int32 NumIndices) { Channels.SetNum(NumIndices); }
 
    int32 GetNumChannels() const { return Channels.Num(); }
 
    void Reset()
    {
        for (FMeshElementContainer& Channel : Channels)
        {
            Channel.Reset();
        }
    }
 
    bool IsEmpty() const
    {
        for (const FMeshElementContainer& Channel : Channels)
        {
            if (Channel.GetArraySize() != 0) { return false; }
        }
 
        return true;
    }
 
    friend FArchive& operator<<(FArchive& Ar, FMeshElementChannels& ElementType)
    {
        Ar << ElementType.Channels;
        return Ar;
    }
 
private:
    // The usual thing is that a MeshElementType has exactly one channel, so we specially reserve a single element inline to save extra allocations
    TArray<FMeshElementContainer, TInlineAllocator<1>> Channels;
};
 
 
class FMeshElementTypeWrapper
{
public:
    explicit FMeshElementTypeWrapper(const int32 NumberOfChannels = 1)
    {
        check(NumberOfChannels > 0);
        Ptr = MakeUnique<FMeshElementChannels>(NumberOfChannels);
    }
 
    FMeshElementTypeWrapper(const FMeshElementTypeWrapper& Other)
    {
        check(Other.Ptr.IsValid());
        Ptr = MakeUnique<FMeshElementChannels>(*Other.Ptr);
    }
 
    FMeshElementTypeWrapper& operator=(const FMeshElementTypeWrapper& Other)
    {
        FMeshElementTypeWrapper Temp(Other);
        Swap(*this, Temp);
        return *this;
    }
 
    FMeshElementTypeWrapper(FMeshElementTypeWrapper&&) = default;
 
    FMeshElementTypeWrapper& operator=(FMeshElementTypeWrapper&&) = default;
 
    const FMeshElementChannels* Get() const { return Ptr.Get(); }
    const FMeshElementChannels* operator->() const { return Ptr.Get(); }
    const FMeshElementChannels& operator*() const { return *Ptr; }
    FMeshElementChannels* Get() { return Ptr.Get(); }
    FMeshElementChannels* operator->() { return Ptr.Get(); }
    FMeshElementChannels& operator*() { return *Ptr; }
 
    friend FArchive& operator<<(FArchive& Ar, FMeshElementTypeWrapper& Wrapper)
    {
        Ar << *Wrapper.Ptr;
        return Ar;
    }
 
private:
    TUniquePtr<FMeshElementChannels> Ptr;
};