DynamicPointSet3.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "BoxTypes.h"
#include "GeometryTypes.h"
#include "MathUtil.h"
#include "Util/DynamicVector.h"
#include "Util/IndexUtil.h"
#include "Util/IteratorUtil.h"
#include "Util/RefCountVector.h"
#include "VectorTypes.h"
#include "VectorUtil.h"
#include "DynamicMesh/DynamicAttribute.h"
 
class FDynamicAttributeSetBase;
 
namespace UE
{
namespace Geometry
{
 
using namespace UE::Math;
 
template<typename RealType>
class TDynamicPointSet3
{
protected:
    FRefCountVector VertexRefCounts;
    TDynamicVector<RealType> Vertices;
 
 
    TDynamicAttributeSetBase<TDynamicPointSet3<RealType>>* BaseAttributeSet = nullptr;
 
 
    //
    // Attribute Set Support. At the level of this class, we do not have a specific attribute set.
    // Clients can provide a pointer to their attribute set so that functions like AppendVertex()
    // or DeleteVertex() will work.
    //
public:
 
    void SetExternallyManagedAttributes(TDynamicAttributeSetBase<TDynamicPointSet3<RealType>>* AttributeSet)
    {
        BaseAttributeSet = AttributeSet;
    }
 
    TDynamicAttributeSetBase<TDynamicPointSet3<RealType>>* GetBaseAttributeSet() const
    {
        return BaseAttributeSet;
    }
 
 
 
    //
    // Indices
    //
public:
 
    int VertexCount() const
    {
        return (int)VertexRefCounts.GetCount();
    }
 
    int MaxVertexID() const
    {
        return (int)VertexRefCounts.GetMaxIndex();
    }
 
 
    inline bool IsVertex(int VertexID) const
    {
        return VertexRefCounts.IsValid(VertexID);
    }
 
 
 
    //
    // Construction
    //
public:
 
    void Clear()
    {
        Vertices.Clear();
        VertexRefCounts = FRefCountVector();
        BaseAttributeSet = nullptr;
    }
 
 
    int AppendVertex(const TVector<RealType>& Position)
    {
        int vid = VertexRefCounts.Allocate();
        int i = 3 * vid;
        Vertices.InsertAt(Position[2], i + 2);
        Vertices.InsertAt(Position[1], i + 1);
        Vertices.InsertAt(Position[0], i);
 
        if (GetBaseAttributeSet() != nullptr)
        {
            GetBaseAttributeSet()->OnNewVertex(vid, false);
        }
 
        return vid;
    }
 
    void BeginUnsafeVerticesInsert()
    {
        // do nothing...
    }
 
    void EndUnsafeVerticesInsert()
    {
        VertexRefCounts.RebuildFreeList();
    }
 
    EMeshResult InsertVertex(int VertexID, const TVector<RealType>& Position, bool bUnsafe = false)
    {
        if (VertexRefCounts.IsValid(VertexID))
        {
            return EMeshResult::Failed_VertexAlreadyExists;
        }
 
        bool bOK = (bUnsafe) ? VertexRefCounts.AllocateAtUnsafe(VertexID) : VertexRefCounts.AllocateAt(VertexID);
        if (bOK == false)
        {
            return EMeshResult::Failed_CannotAllocateVertex;
        }
 
        int i = 3 * VertexID;
        Vertices.InsertAt(Position[2], i + 2);
        Vertices.InsertAt(Position[1], i + 1);
        Vertices.InsertAt(Position[0], i);
 
        if (GetBaseAttributeSet() != nullptr)
        {
            GetBaseAttributeSet()->OnNewVertex(VertexID, true);
        }
 
        return EMeshResult::Ok;
    }
 
 
 
    //
    // get/set
    //
public:
 
    inline TVector<RealType> GetVertex(int VertexID) const
    {
        check(IsVertex(VertexID));
        int i = 3 * VertexID;
        return TVector<RealType>(Vertices[i], Vertices[i + 1], Vertices[i + 2]);
    }
 
    inline void SetVertex(int VertexID, const TVector<RealType>& vNewPos)
    {
        //check(VectorUtil::IsFinite(vNewPos));
        check(IsVertex(VertexID));
        int i = 3 * VertexID;
        Vertices[i] = vNewPos.X;
        Vertices[i + 1] = vNewPos.Y;
        Vertices[i + 2] = vNewPos.Z;
    }
 
 
 
    //
    // iterators
    //
public:
    FRefCountVector::IndexEnumerable VertexIndicesItr() const
    {
        return VertexRefCounts.Indices();
    }
 
    FRefCountVector::MappedEnumerable<TVector<RealType>> VerticesItr() const
    {
        return VertexRefCounts.MappedIndices<TVector<RealType>>([this](int VertexID) {
            int i = 3 * VertexID;
            return TVector<RealType>(Vertices[i], Vertices[i + 1], Vertices[i + 2]);
        });
    }
 
 
 
 
    bool IsCompact() const
    {
        return VertexRefCounts.IsDense();
    }
 
    RealType CompactMetric() const
    {
        return ((RealType)VertexCount() / (RealType)MaxVertexID());
    }
 
    //
    // Geometric queries
    //
public:
 
    TAxisAlignedBox3<RealType> GetBounds() const
    {
        TAxisAlignedBox3<RealType> Box = TAxisAlignedBox3<RealType>::Empty();
        for (int vi : VertexIndicesItr())
        {
            int k = 3 * vi;
            Box.Contain( TVector<RealType>(Vertices[k], Vertices[k + 1], Vertices[k + 2]) );
        }
        return Box;
    }
 
 
 
    //
    // direct buffer access  (not a good idea to use)
    //
public:
    const TDynamicVector<double>& GetVerticesBuffer()
    {
        return Vertices;
    }
    const FRefCountVector& GetVerticesRefCounts()
    {
        return VertexRefCounts;
    }
 
 
 
    //
    // Edit operations
    //
public:
 
    // @todo port this from DynamicMesh3
    //void CompactInPlace(FCompactMaps* CompactInfo = nullptr);
 
    EMeshResult RemoveVertex(int VertexID)
    {
        if (VertexRefCounts.IsValid(VertexID) == false)
        {
            return EMeshResult::Failed_NotAVertex;
        }
        VertexRefCounts.Decrement(VertexID);
        check(VertexRefCounts.IsValid(VertexID) == false);
 
        if (GetBaseAttributeSet() != nullptr)
        {
            GetBaseAttributeSet()->OnRemoveVertex(VertexID);
        }
 
        return EMeshResult::Ok;
    }
 
};
 
 
 
typedef TDynamicPointSet3<float> FDynamicPointSet3f;
typedef TDynamicPointSet3<double> FDynamicPointSet3d;
 
 
} // end namespace UE::Geometry
} // end namespace UE