SparseGrid2.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "BoxTypes.h"
#include "IntBoxTypes.h"
 
// 2d version of TSparseGrid3
 
namespace UE
{
namespace Geometry
{
 
template<typename ElemType>
class TSparseGrid2
{
protected:
    TMap<FVector2i, ElemType*> Elements;
    FAxisAlignedBox2i Bounds;
 
public:
 
    TSparseGrid2()
    {
        Bounds = FAxisAlignedBox2i::Empty();
    }
 
    ~TSparseGrid2()
    {
        FreeAll();
    }
 
 
    TSparseGrid2(const TSparseGrid2& Other) = delete;
    TSparseGrid2& operator=(const TSparseGrid2& Other) = delete;
    TSparseGrid2(TSparseGrid2&& Other) noexcept : Elements(MoveTemp(Other.Elements)), Bounds(MoveTemp(Other.Bounds))
    {
        Other.Elements.Reset();
    }
    TSparseGrid2& operator=(TSparseGrid2&& Other) noexcept
    {
        if (this != &Other)
        {
            Elements = MoveTemp(Other.Elements);
            Bounds = MoveTemp(Other.Bounds);
            Other.Elements.Reset();
        }
        return *this;
    }
 
    bool Has(const FVector2i& Index) const
    {
        return Elements.Contains(Index);
    }
 
 
    const ElemType* Get(const FVector2i& Index) const
    {
        return Elements.FindRef(Index);
    }
 
 
    ElemType* Get(const FVector2i& Index, bool bAllocateIfMissing)
    {
        ElemType* result = Elements.FindRef(Index);
        if (result != nullptr)
        {
            return result;
        }
        if (bAllocateIfMissing == true)
        {
            return Allocate(Index);
        }
        return nullptr;
    }
 
    bool Free(const FVector2i& 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.Area();
    }
 
    FAxisAlignedBox2i GetBoundsInclusive() const
    {
        return Bounds;
    }
 
    FVector2i GetDimensions() const
    {
        return Bounds.Diagonal() + FVector2i::One();
    }
 
 
    template<typename Func>
    void AllocatedIteration(Func ElementFunc) const
    {
        for (auto Pair : Elements)
        {
            ElementFunc(Pair.Value);
        }
    }
 
 
    template<typename Func>
    void RangeIteration(FVector2i MinIndex, FVector2i MaxIndex, Func ElementFunc) const
    {
        for (int32 yi = MinIndex.Y; yi <= MaxIndex.Y; ++yi)
        {
            for (int32 xi = MinIndex.X; xi <= MaxIndex.X; ++xi)
            {
                const ElemType* Found = Elements.FindRef(FVector2i(xi,yi));
                if (Found != nullptr)
                {
                    ElementFunc(*Found);
                }
            }
        }
    }
 
    SIZE_T GetAllocatedSize() const
    {
        return Elements.GetAllocatedSize() + GetCount() * sizeof(ElemType);
    }
 
protected:
 
    ElemType* Allocate(const FVector2i& index)
    {
        ElemType* NewElem = new ElemType();
        Elements.Add(index, NewElem);
        Bounds.Contain(index);
        return NewElem;
    }
};
 
} // end namespace UE::Geometry
} // end namespace UE