DynamicVerticesOctree3.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Spatial/MeshAABBTree3.h"
#include "Spatial/SparseDynamicPointOctree3.h"
#include "MeshQueries.h"
#include "Intersection/IntersectionUtil.h"
#include "DynamicMesh/DynamicMesh3.h"
 
namespace UE
{
namespace Geometry
{
 
template<typename SourceType>
class TDynamicVerticesOctree3 : public FSparseDynamicPointOctree3
{
    // potential optimizations:
    //    - keep track of how many vertices are descendents of each cell? root cells?
 
 
 
public:
    const SourceType* VertexSource;
 
    FAxisAlignedBox3d ModifiedBounds;
 
    double HitSphereRadius = 1.0f;
 
    void Initialize(const SourceType* VertexSourceIn, bool bDynamicExpand)
    {
        this->VertexSource = VertexSourceIn;
 
        HitSphereRadius = VertexSourceIn->GetBounds().Diagonal().Length() * 0.001;
 
        int MaxVertexID = VertexSource->MaxVertexID();
        for ( int VertexID = 0; VertexID < MaxVertexID; VertexID++ )
        {
            if (VertexSource->IsVertex(VertexID))
            {
                if (bDynamicExpand)
                {
                    ModifiedBounds.Contain(VertexSource->GetVertex(VertexID));
                    const SourceType* VtxSource = VertexSource;
                    FSparseDynamicPointOctree3::InsertPoint_DynamicExpand(
                        VertexID,
                        [VtxSource](int k) { return VtxSource->GetVertex(k); });
                }
                else
                {
                    InsertVertex(VertexID);
                }
            }
        }
    }
 
    void ResetModifiedBounds()
    {
        ModifiedBounds = FAxisAlignedBox3d::Empty();
    }
 
    void InsertVertex(int32 VertexID)
    {
        FVector3d Point = VertexSource->GetVertex(VertexID);
        ModifiedBounds.Contain(Point);
        FSparseDynamicPointOctree3::InsertPoint(VertexID, Point);
    }
 
    void InsertVertices(const TArray<int>& Vertices)
    {
        int N = Vertices.Num();
        for (int i = 0; i < N; ++i)
        {
            FVector3d Point = VertexSource->GetVertex(Vertices[i]);
            ModifiedBounds.Contain(Point);
            FSparseDynamicPointOctree3::InsertPoint(Vertices[i], Point);
        }
    }
 
    void InsertVertices(const TSet<int>& Vertices)
    {
        for (int VertexID : Vertices)
        {
            FVector3d Point = VertexSource->GetVertex(VertexID);
            ModifiedBounds.Contain(Point);
            FSparseDynamicPointOctree3::InsertPoint(VertexID, Point);
        }
    }
 
 
    bool RemovePoint(int32 VertexID)
    {
        FVector3d Point = VertexSource->GetVertex(VertexID);
        ModifiedBounds.Contain(Point);
        return FSparseDynamicPointOctree3::RemovePoint(VertexID);
    }
 
    void RemoveVertices(const TArray<int>& Vertices)
    {
        int N = Vertices.Num();
        for ( int i = 0; i < N; ++i )
        {
            FVector3d Point = VertexSource->GetVertex(Vertices[i]);
            ModifiedBounds.Contain(Point);
            FSparseDynamicPointOctree3::RemovePoint(Vertices[i]);
        }
    }
 
    void RemoveVertices(const TSet<int>& Vertices)
    {
        for (int VertexID : Vertices)
        {
            FVector3d Point = VertexSource->GetVertex(VertexID);
            ModifiedBounds.Contain(Point);
            FSparseDynamicPointOctree3::RemovePoint(VertexID);
        }
    }
 
 
    void ReinsertVertices(const TSet<int>& Vertices)
    {
        for (int VertexID : Vertices)
        {
            FVector3d Point = VertexSource->GetVertex(VertexID);
            ModifiedBounds.Contain(Point);
            FSparseDynamicPointOctree3::ReinsertPoint(VertexID, Point);
        }
    }
 
 
    void NotifyPendingModification(int VertexID)
    {
        FVector3d Point = VertexSource->GetVertex(VertexID);
        ModifiedBounds.Contain(Point);
    }
 
    void NotifyPendingModification(const TSet<int>& Vertices)
    {
        for (int VertexID : Vertices)
        {
            FVector3d Point = VertexSource->GetVertex(VertexID);
            ModifiedBounds.Contain(Point);
        }
    }
 
 
    int32 FindNearestHitVertex(const FRay3d& Ray,
        double MaxDistance = TNumericLimits<double>::Max()) const
    {
        return FSparseDynamicPointOctree3::FindNearestHitPoint(Ray,
            [this](int vid, const FRay3d& Ray) {
                FVector3d Point = VertexSource->GetVertex(vid);
                FLinearIntersection Hit = IntersectionUtil::RaySphereIntersection(Ray.Origin, Ray.Direction, Point, HitSphereRadius);
                return (Hit.intersects) ? Hit.parameter.Min : TNumericLimits<double>::Max();
            }, MaxDistance);
    }
 
 
    void CheckValidity(
        EValidityCheckFailMode FailMode = EValidityCheckFailMode::Check,
        bool bVerbose = false,
        bool bFailOnMissingPoints = false) const
    {
        FSparseDynamicPointOctree3::CheckValidity(
            [&](int vid) { return VertexSource->IsVertex(vid); },
            [this](int vid) { return VertexSource->GetVertex(vid); },
            FailMode, bVerbose, bFailOnMissingPoints);
    }
 
 
};
 
 
 
} // end namespace UE::Geometry
} // end namespace UE