SparseGrid3.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3Sharp DSparseGrid3
 
#pragma once
 
#include "CoreMinimal.h"
#include "BoxTypes.h"
#include "IntBoxTypes.h"
 
namespace UE
{
namespace Geometry
{
 
template<typename ElemType>
class TSparseGrid3
{
protected:
    TMap<FVector3i, ElemType*> Elements;
    FAxisAlignedBox3i Bounds;
 
public:
 
    TSparseGrid3()
    {
        Bounds = FAxisAlignedBox3i::Empty();
    }
 
    ~TSparseGrid3()
    {
        FreeAll();
    }
 
 
    TSparseGrid3(const TSparseGrid3& Other) = delete;
    TSparseGrid3& operator=(const TSparseGrid3& Other) = delete;
    TSparseGrid3(TSparseGrid3&& Other) noexcept : Elements(MoveTemp(Other.Elements)), Bounds(MoveTemp(Other.Bounds))
    {
        Other.Elements.Reset();
    }
    TSparseGrid3& operator=(TSparseGrid3&& Other) noexcept
    {
        if (this != &Other)
        {
            Elements = MoveTemp(Other.Elements);
            Bounds = MoveTemp(Other.Bounds);
            Other.Elements.Reset();
        }
        return *this;
    }
 
    bool Has(const FVector3i& Index) const
    {
        return Elements.Contains(Index);
    }
 
 
    const ElemType* Get(const FVector3i& Index) const
    {
        return Elements.FindRef(Index);
    }
 
 
    ElemType* Get(const FVector3i& Index, bool bAllocateIfMissing)
    {
        ElemType* result = Elements.FindRef(Index);
        if (result != nullptr)
        {
            return result;
        }
        if (bAllocateIfMissing == true)
        {
            return Allocate(Index);
        }
        return nullptr;
    }
 
    bool Free(const FVector3i& Index)
    {
        if (Elements.Contains(Index))
        {
            delete Elements[Index];
            Elements.Remove(Index);
            return true;
        }
        return false;
    }
 
    void FreeAll()
    {
        for (auto pair : Elements)
        {
            delete pair.Value;
        }
        Elements.Reset();
    }
 
    int GetCount() const
    {
        return Elements.Num();
    }
 
    float GetDensity() const
    {
        return (float)Elements.Num() / (float)Bounds.Volume();
    }
 
    FAxisAlignedBox3i GetBoundsInclusive() const
    {
        return Bounds;
    }
 
    FVector3i GetDimensions() const
    {
        return Bounds.Diagonal() + FVector3i::One();
    }
 
 
    template<typename Func>
    void AllocatedIteration(Func ElementFunc) const
    {
        for (auto Pair : Elements)
        {
            ElementFunc(Pair.Value);
        }
    }
 
 
    template<typename Func>
    void RangeIteration(FVector3i MinIndex, FVector3i MaxIndex, Func ElementFunc) const
    {
        for (int32 zi = MinIndex.Z; zi <= MaxIndex.Z; ++zi)
        {
            for (int32 yi = MinIndex.Y; yi <= MaxIndex.Y; ++yi)
            {
                for (int32 xi = MinIndex.X; xi <= MaxIndex.X; ++xi)
                {
                    const ElemType* Found = Elements.FindRef(FVector3i(xi,yi,zi));
                    if (Found != nullptr)
                    {
                        ElementFunc(*Found);
                    }
                }
            }
        }
    }
 
 
 
protected:
 
    ElemType* Allocate(const FVector3i& index)
    {
        ElemType* NewElem = new ElemType();
        Elements.Add(index, NewElem);
        Bounds.Contain(index);
        return NewElem;
    }
};
 
} // end namespace UE::Geometry
} // end namespace UE