BlockedDenseGrid3.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3Sharp BlockedDenseGrid3
 
#pragma once
 
#include "CoreMinimal.h"
#include "BlockedLayout3.h"
#include "BoxTypes.h"
#include "Containers/BitArray.h"
#include "Containers/StaticArray.h"
#include "Misc/ScopeLock.h"
#include "HAL/CriticalSection.h"
 
 
namespace UE
{
namespace Geometry
{
 
// Block Data Buffer, holds linear array of typed data
template <typename ElemType_, int32 BlockSize_>
class TBlockData3 : public TBlockData3Layout<BlockSize_>
{
public:
    typedef TBlockData3Layout<BlockSize_>                        DataLayout;
    typedef ElemType_                                            ElemType;
    typedef TStaticArray<ElemType, DataLayout::ElemCount>        LinearDataStorageType;
 
    TBlockData3()
    :Id(-1)
    {}
 
    TBlockData3(const ElemType& Value, const int32 ID)
    :Id(ID)
    {
        Reset(Value);
    }
 
    void Reset(const ElemType& Value)
    {
        for (int32 k = 0, K = DataLayout::ElemCount; k < K; ++k)
        {
            Data[k] = Value;
        }
    }
 
    ElemType& At(const int32 Index)
    {
        checkSlow(Index < DataLayout::ElemCount);
        return Data[Index];
    }
    ElemType At(const int32 Index) const 
    {
        checkSlow(Index < DataLayout::ElemCount);
        return Data[Index];
    }
 
    template <typename FuncType>
    void ModifyValue(const int32 Index, FuncType Func)
    {
        ElemType& Value = Data[Index];
        Func(Value);
    }
 
    int32                        Id;          // an id associated with this block data.
    LinearDataStorageType        Data;        // payload
 
};
 
// Specialize the Block Data Buffer for bools by using a bitarray. 
template <int32 BlockSize_>
class TBlockData3<bool, BlockSize_> : public TBlockData3Layout<BlockSize_>
{
public:
    typedef TBlockData3Layout<BlockSize_>                       DataLayout;
    typedef bool                                                ElemType;
    typedef TInlineAllocator<DataLayout::ElemCount>             AllocatorType;
    typedef TBitArray<AllocatorType>                            BlockDataBitMask;
    typedef TConstSetBitIterator<AllocatorType>                 BitArrayConstIterator;
 
    TBlockData3(const ElemType& Value, const int32 ID)
        :Id(ID)
    {
        Reset(Value);
    }
 
    void Reset(const ElemType& Value)
    {
        BitArray.Init(Value, DataLayout::ElemCount);
    }
 
    FBitReference At(int32 LocalIndex)
    {
        checkSlow(LocalIndex < DataLayout::ElemCount);
        return BitArray[LocalIndex];
    }
 
    bool At(int32 LocalIndex) const
    {
        checkSlow(LocalIndex < DataLayout::ElemCount);
        return BitArray[LocalIndex];
    }
 
    template <typename FuncType>
    void ModifyValue(const int32 Index, FuncType Func)
    {
        bool Value = BitArray[Index];
        Func(Value);
        BitArray[Index] = Value;
    }
 
    // bit field operations can correspond to topological operations
    void TopologyUnion(const TBlockData3<bool, BlockSize_>& OtherBlockData)
    {
        const auto& OtherBitArray = OtherBlockData.BitArray;
        BitArray.CombineWithBitwiseOR(OtherBitArray, EBitwiseOperatorFlags::MaintainSize);
    }
 
    int32                        Id;
    BlockDataBitMask             BitArray;    
};
 
 
template<typename ElemType, int32 BlockSize_>
class TBasicBlockedDenseGrid3 : public TBlockedGrid3Layout<BlockSize_>
{
public:
    typedef TBlockedGrid3Layout<BlockSize_>                                   BlockedGrid3LayoutType;
    typedef TBlockData3<ElemType, BlockSize_>                                 BlockData3Type;
 
 
    static constexpr int32 BlockSize      = BlockSize_;                         // length of side of a block
    static constexpr int32 BlockElemCount = BlockSize * BlockSize * BlockSize;  // number of cells in each block
protected:
 
    ElemType DefaultValue = (ElemType)0;
 
 
    // a default value and a pointer to a block that will be allocated on first write.
    struct FBlock3
    {
        // release any allocated block data and reset the default value.
        void Reset(const ElemType& DefaultIn = (ElemType)0)
        {
            BlockDataPtr.Reset();
            DefaultValue = DefaultIn;
        }
 
        ElemType  GetValue(const int32& LocalIndex) const 
        {
            return (BlockDataPtr.IsValid()) ? BlockDataPtr->At(LocalIndex) : DefaultValue;
        }
 
        TUniquePtr<BlockData3Type>  BlockDataPtr;     // pointer to 'heavy' data
        ElemType                    DefaultValue;     // value to be used when BlockData is not allocated
    };
 
 
    TArray<FBlock3>          Blocks;                 // array of blocks that span the dimensions of the gird.
    
 
protected:
 
    // declare other templated instantiations as friends so that PreAllocateFromSourceGrid() can work
    template<class OtherElemType, int32 OtherBlockSize> friend class TBasicBlockedDenseGrid3;
 
    //friend class TBlockedDenseBitGrid3<BlockSize>;
 
#if UE_BUILD_DEBUG
    FBlock3& GetBlock(int32 Index) { return Blocks[Index]; }
    const FBlock3& GetBlock(int32 Index) const { return Blocks[Index]; }
#else
    // skip range checks in non-debug builds
    FBlock3& GetBlock(int32 Index) { return Blocks.GetData()[Index]; }
    const FBlock3& GetBlock(int32 Index) const { return Blocks.GetData()[Index]; }
#endif
 
    bool IsBlockAllocated(const FBlock3& Block) const
    {
        return Block.BlockDataPtr.IsValid();
    }
    bool IsBlockAllocated(const int32 BlockIndex) const
    {
        const FBlock3& Block = GetBlock(BlockIndex);
        return IsBlockAllocated(Block);
    }
 
    BlockData3Type& TouchBlockData(const int32 BlockIndex)
    {
        FBlock3& Block = GetBlock(BlockIndex);
        if (!IsBlockAllocated(Block))
        {
            const ElemType& Value = Block.DefaultValue;
            Block.BlockDataPtr = MakeUnique<BlockData3Type>(Value, BlockIndex);
        }
        return *Block.BlockDataPtr;
    }
 
    // --- write methods
    template <typename FuncType>
    void WriteValue(const int32& BlockIndex, const int32& LocalIndex, FuncType Func)
    {
        BlockData3Type& BlockData = TouchBlockData(BlockIndex);
        BlockData.ModifyValue(LocalIndex, Func);
    }
 
    template<typename FuncType>
    void WriteValue(int32 I, int32 J, int32 K, FuncType Func)
    {
        int32 BlockIndex, LocalIndex;
        BlockedGrid3LayoutType::GetBlockAndLocalIndex(I, J, K, BlockIndex, LocalIndex);
        WriteValue(BlockIndex, LocalIndex, Func);
    }
    
    template <typename FuncType>
    void WriteValueWithLock(const int32& BlockIndex, const int32& LocalIndex,  FuncType Func, FCriticalSection* CriticalSection)
    {
        FScopeLock Lock(CriticalSection);
        WriteValue(BlockIndex, LocalIndex, Func);
    }
 
    // --- read methods
 
    ElemType ReadValue(const int32& BlockIndex, const int32& LocalIndex) const 
    {
        return GetBlock(BlockIndex).GetValue(LocalIndex);
    }
 
    ElemType ReadValue(int32 I, int32 J, int32 K) const
    {
        int32 BlockIndex, LocalIndex;
        BlockedGrid3LayoutType::GetBlockAndLocalIndex(I, J, K, BlockIndex, LocalIndex);
        return ReadValue(BlockIndex, LocalIndex);
    }
 
    ElemType ReadValueWithLock(const int32& BlockIndex, const int32& LocalIndex, FCriticalSection* CriticalSection)
    {
        FScopeLock Lock(CriticalSection);
        return ReadValue(BlockIndex, LocalIndex);
    }
 
 
 
public:
    TBasicBlockedDenseGrid3() : BlockedGrid3LayoutType(0,0,0)
    {
    }
 
    TBasicBlockedDenseGrid3(int32 DimI, int32 DimJ, int32 DimK, ElemType InitialValue)
    {
        DefaultValue = InitialValue;
        Resize(DimI, DimJ, DimK);
    }
 
    void Resize(int32 DimI, int32 DimJ, int32 DimK)
    {       
        BlockedGrid3LayoutType::Resize(DimI, DimJ, DimK);
        const int32 NumBlocks = GetNumBlocks();
 
        Blocks.Reset();
        Blocks.SetNum(NumBlocks);
        for (int32 k = 0; k < NumBlocks; ++k)
        {
            Blocks[k].Reset(DefaultValue);
        }
    }
 
    void Reset()
    {
        Reset(BlockedGrid3LayoutType::Dimensions.X, BlockedGrid3LayoutType::Dimensions.Y, BlockedGrid3LayoutType::Dimensions.Z, DefaultValue);
    }
 
    void Reset(int32 DimI, int32 DimJ, int32 DimK, ElemType InitialValue)
    {
        DefaultValue = InitialValue;
        Resize(DimI, DimJ, DimK);
    }
 
    ElemType GetValue(int32 I, int32 J, int32 K) const
    {
        return ReadValue(I, J, K);
    }
 
    ElemType GetValue(const FVector3i& CellIJK) const
    {
        return ReadValue(CellIJK.X, CellIJK.Y, CellIJK.Z);
    }
 
 
    void SetValue(int32 I, int32 J, int32 K, ElemType NewValue)
    {
        WriteValue(I, J, K, [NewValue](ElemType& GridValueInOut) { GridValueInOut = NewValue; });
    }
 
    void SetValue(const FVector3i& CellIJK, ElemType NewValue)
    {
        WriteValue(CellIJK.X, CellIJK.Y, CellIJK.Z, [NewValue](ElemType& GridValueInOut) { GridValueInOut = NewValue; });
    }
 
 
    template<typename ProcessFunc>
    void ProcessValue(int32 I, int32 J, int32 K, ProcessFunc Func)
    {
        WriteValue(I, J, K, Func);
    }
 
    template<typename ProcessFunc>
    void ProcessValue(const FVector3i& CellIJK, ProcessFunc Func)
    {
        WriteValue(CellIJK.X, CellIJK.Y, CellIJK.Z, Func);
    }
 
 
    template <typename OtherElemType>
    bool PreAllocateFromSourceGrid(const TBasicBlockedDenseGrid3<OtherElemType, BlockSize>& SourceGrid)
    {
        return AllocateTopologyUnionImpl(SourceGrid);
    }
 
    int32 GetNumBlocks() const
    {
        const FVector3i& BlockDims = BlockedGrid3LayoutType::GetBlockDimensions();
        return BlockDims.X * BlockDims.Y * BlockDims.Z;
    }
 
protected:
    template <typename OtherGridType >
    bool AllocateTopologyUnionImpl(const OtherGridType& OtherGrid)
    {
 
        // bound checking
        if ((BlockedGrid3LayoutType::GetDimensions() != OtherGrid.GetDimensions()) || (BlockedGrid3LayoutType::GetBlockDimensions() != OtherGrid.GetBlockDimensions()))
        {
            check(false);       // this is almost certainly a development-time error in calling code
            return false;
        }
 
        const int32 NumBlocks = GetNumBlocks();
        for (int32 k = 0; k < NumBlocks; ++k)
        {
            if (OtherGrid.IsBlockAllocated(k))
            {
                TouchBlockData(k);
            }
        }
        return true;
    }
};
 
template<typename ElemType, int32 BlockSize_>
class TBlockedGrid3 : public TBasicBlockedDenseGrid3<ElemType, BlockSize_>
{
public:
    typedef TBasicBlockedDenseGrid3<ElemType, BlockSize_>                     BlockedDenseGridType;
    typedef TBlockedGrid3Layout<BlockSize_>                                   BlockedGrid3LayoutType;
    typedef TBlockData3<ElemType, BlockSize_>                                 BlockData3Type;
 
 
    static constexpr int32 BlockSize      = BlockSize_;                         // length of side of a block
    static constexpr int32 BlockElemCount = BlockSize * BlockSize * BlockSize;  // number of cells in each block
 
 
protected:
 
    typedef typename TBasicBlockedDenseGrid3<ElemType, BlockSize_>::FBlock3           FBlock3;
 
 
    template<typename FuncType>
    void WriteBlockDefaultValue(const int32 BlockIndex, FuncType Func, bool bDeallocateBock = true)
    {
        FBlock3& Block = BlockedDenseGridType::GetBlock(BlockIndex);
        Func(Block.DefaultValue);
        if (bDeallocateBock)
        {
            Block.BlockDataPtr.Reset();
        }
    }
 
    template <typename FuncType>
    void WriteBlockDefaultValue(const FVector3i& BlockIJK, FuncType Func, bool bDeallocateBock = true)
    {
        const int32 BlockIndex = BlockedGrid3LayoutType::BlockIJKToBlockIndex(BlockIJK);
        WriteBlockDefaultValue(BlockIndex, Func, bDeallocateBock);
    }
 
    template<typename FuncType>
    void WriteBlockDefaultValueWithLock(const int32 BlockIndex, FuncType Func, FCriticalSection* CriticalSection, bool bDeallocateBock = true)
    {
        FScopeLock Lock(CriticalSection);
        WriteBlockDefaultValue(BlockIndex, Func, bDeallocateBock);
    }
 
 
    // -- block-level default value read methods.
 
    ElemType ReadBlockDefaultValue(const int32& BlockIndex) const
    {
        return BlockedDenseGridType::GetBlock(BlockIndex).DefaultValue;
    }
 
    ElemType ReadBlockDefaultValue(const FVector3i& BlockIJK) const
    {
        const int32 BlockIndex = BlockedGrid3LayoutType::BlockIJKToBlockIndex(BlockIJK);
        return ReadBlockDefaultValue(BlockIndex);
    }
 
public:
    TBlockedGrid3() :  BlockedDenseGridType()
    {
    }
 
    TBlockedGrid3(int32 DimI, int32 DimJ, int32 DimK, ElemType InitialValue)
    : BlockedDenseGridType(DimI, DimJ, DimK, InitialValue)
    {
    }
 
 
    // -- methods to set values when using locks.
 
    template <typename CriticalSectionProviderType>
    void SetValueWithLock(int32 I, int32 J, int32 K, ElemType NewValue, CriticalSectionProviderType& CriticalSectionProvider)
    {
        int32 BlockIndex, LocalIndex;
        BlockedGrid3LayoutType::GetBlockAndLocalIndex(I, J, K, BlockIndex, LocalIndex);
        FCriticalSection& CriticalSection = CriticalSectionProvider(BlockIndex);
        BlockedDenseGridType::WriteValueWithLock(BlockIndex, LocalIndex, [&NewValue](ElemType& Value){Value = NewValue;}, &CriticalSection);
    }
 
    template <typename CriticalSectionProviderType>
    void SetValueWithLock(const FVector3i& CellIJK, ElemType NewValue,  CriticalSectionProviderType CriticalSectionProvider)
    {
        SetValueWithLock(CellIJK.X, CellIJK.Y, CellIJK.Z, NewValue, CriticalSectionProvider);
    }
 
    template<typename ProcessFunc, typename CriticalSectionProviderType>
    void ProcessValueWithLock(int32 I, int32 J, int32 K, ProcessFunc Func, CriticalSectionProviderType CriticalSectionProvider)
    {
        int32 BlockIndex, LocalIndex;
        BlockedGrid3LayoutType::GetBlockAndLocalIndex(I, J, K, BlockIndex, LocalIndex);
        FCriticalSection& CriticalSection = CriticalSectionProvider(BlockIndex);
        BlockedDenseGridType::WriteValueWithLock(BlockIndex, LocalIndex, Func, &CriticalSection);
    }
 
    template<typename ProcessFunc, typename CriticalSectionProviderType>
    void ProcessValueWithLock(const FVector3i& CellIJK, ProcessFunc Func, CriticalSectionProviderType CriticalSectionProvider)
    {
        ProcessValueWithLock(CellIJK.X, CellIJK.Y, CellIJK.Z, Func, CriticalSectionProvider);
    }
 
    // -- block access methods ---/
 
    int32 GetNumBlocks() const
    {
        const FVector3i& BlockDims = BlockedGrid3LayoutType::GetBlockDimensions();
        return BlockDims.X * BlockDims.Y * BlockDims.Z;
    }
 
    TArray<const BlockData3Type*> GetAllocatedConstBlocks() const
    {
        TArray<const BlockData3Type*> Result;
        const int32 NumBlocks = BlockedDenseGridType::GetNumBlocks();
        for (int32 i = 0; i < NumBlocks; ++i)
        {
            if (BlockedDenseGridType::IsBlockAllocated(i))
            {
                Result.Add(BlockedDenseGridType::Blocks[i].BlockDataPtr.Get());
            }
        }
        return Result;
    }
 
    TArray<BlockData3Type*> GetAllocatedBlocks()
    {
        TArray<BlockData3Type*> Result;
        const int32 NumBlocks = BlockedDenseGridType::GetNumBlocks();
        for (int32 i = 0; i < NumBlocks; ++i)
        {
            if (BlockedDenseGridType::IsBlockAllocated(i))
            {
                Result.Add(BlockedDenseGridType::Blocks[i].BlockDataPtr.Get());
            }
        }
        return Result;
    }
 
    TArray<const BlockData3Type*> GetAllocatedBlocks() const
    {
        return GetAllocatedConstBlocks();
    }
 
    bool IsBlockAllocated(const FVector3i& BlockIJK) const
    {
        return GetBlockData(BlockIJK).IsValid();
    }
 
    BlockData3Type& TouchBlockData(const FVector3i& BlockIJK)
    {
        const int32 BlockIndex = BlockedGrid3LayoutType::BlockIJKToBlockIndex(BlockIJK);
        return BlockedDenseGridType::TouchBlockData(BlockIndex);
    }
 
    TUniquePtr<BlockData3Type>& GetBlockData(const FVector3i& BlockIJK)
    {
        const int32 BlockIndex = BlockedGrid3LayoutType::BlockIJKToBlockIndex(BlockIJK);
        return GetBlockData(BlockIndex);
    }
 
    const TUniquePtr<BlockData3Type>& GetBlockData(const FVector3i& BlockIJK) const
    {
        const int32 BlockIndex = BlockedGrid3LayoutType::BlockIJKToBlockIndex(BlockIJK);
        return GetBlockData(BlockIndex);
    }
 
    TUniquePtr<BlockData3Type>& GetBlockData(int32 BlockIndex)
    {
        return BlockedDenseGridType::GetBlock(BlockIndex).BlockDataPtr;
    }
 
    const TUniquePtr<BlockData3Type>& GetBlockData(int32 BlockIndex) const
    {
        return BlockedDenseGridType::GetBlock(BlockIndex).BlockDataPtr;
    }
 
    // --- methods on the block's default values.  
    // ---  The block 'default value' is returned when querying a cell in an unallocated block, and is used to initialize the block on allocation.
 
    ElemType GetBlockDefaultValue(const FVector3i& BlockIJK) const
    {
        return ReadBlockDefaultValue(BlockIJK);
    }
 
    void SetBlockDefaultValue(const FVector3i& BlockIJK, const ElemType& Value, bool bPruneBlock = true)
    {
        WriteBlockDefaultValue(BlockIJK, [&Value](ElemType& oldValue){ oldValue = Value;}, bPruneBlock);
    }
 
    template<typename ProcessFunc>
    void ProcessBlockDefaultValue(const FVector3i& BlockIJK, ProcessFunc Func, bool bPruneBlock = true)
    {
        WriteBlockDefaultValue(BlockIJK, Func, bPruneBlock);
    }
};
 
// Note on the block size: 8 seems to be the sweet spot with vastly better performance in SDF generation
// perhaps because a float block can fit in the L1 cache with room to spare.
typedef TBlockedGrid3<float, 8>  FBlockedGrid3f;
typedef TBlockedGrid3<double, 8> FBlockedGrid3d;
typedef TBlockedGrid3<int, 8>    FBlockedGrid3i;
 
// note the bool grid uses a bitfield specialization
typedef TBlockedGrid3<bool, 8>   FBlockedGrid3b;
 
template<typename ElemType>
class TBlockedDenseGrid3 : public TBasicBlockedDenseGrid3<ElemType, 32>
{
public:
    
    static constexpr int32 BlockSize = 32;
    static constexpr int32 BlockElemCount = BlockSize * BlockSize * BlockSize;
    
    typedef TBasicBlockedDenseGrid3<ElemType, BlockSize>                     BlockedDenseGridType;
    typedef TBlockedGrid3Layout<BlockSize>                                   BlockedGrid3LayoutType;
    typedef TBlockData3<ElemType, BlockSize>                                 BlockData3Type;
 
 
    
 
protected:
 
    TArray<FCriticalSection> BlockLocks;             // per-block level lock used for thread-safe methods
 
#if UE_BUILD_DEBUG
 
    FCriticalSection* GetBlockLock(int32 Index) { return &BlockLocks[Index]; }
#else
    // skip range checks in non-debug builds
    FCriticalSection* GetBlockLock(int32 Index) { return &BlockLocks.GetData()[Index]; }
#endif
 
    template<typename FuncType>
    void WriteValueThreadSafe(int32 I, int32 J, int32 K, FuncType Func)
    {
        int32 BlockIndex, LocalIndex;
        BlockedGrid3LayoutType::GetBlockAndLocalIndex(I, J, K, BlockIndex, LocalIndex);
        BlockedDenseGridType::WriteValueWithLock(BlockIndex, LocalIndex, Func, GetBlockLock(BlockIndex));
    }
 
 
    ElemType ReadValueThreadSafe(int32 I, int32 J, int32 K)
    {
        int32 BlockIndex, LocalIndex;
        BlockedGrid3LayoutType::GetBlockAndLocalIndex(I, J, K, BlockIndex, LocalIndex);
        return BlockedDenseGridType::ReadValueWithLock(BlockIndex, LocalIndex, GetBlockLock(BlockIndex));
    }
 
public:
 
    TBlockedDenseGrid3() : BlockedDenseGridType()
    {
    }
 
    TBlockedDenseGrid3(int32 DimI, int32 DimJ, int32 DimK, ElemType InitialValue)
    {
        BlockedDenseGridType::DefaultValue = InitialValue;
        Resize(DimI, DimJ, DimK);
    }
 
    void Resize(int32 DimI, int32 DimJ, int32 DimK)
    {
        BlockedDenseGridType::Resize(DimI, DimJ, DimK);
 
        const int32 NumBlocks = BlockedDenseGridType::GetNumBlocks();
        BlockLocks.Reset();
        BlockLocks.SetNum(NumBlocks);
    }
 
    void Reset()
    {
        Reset(BlockedGrid3LayoutType::Dimensions.X, BlockedGrid3LayoutType::Dimensions.Y, BlockedGrid3LayoutType::Dimensions.Z, BlockedDenseGridType::DefaultValue);
    }
 
    void Reset(int32 DimI, int32 DimJ, int32 DimK, ElemType InitialValue)
    {
        BlockedDenseGridType::DefaultValue = InitialValue;
        Resize(DimI, DimJ, DimK);
    }
 
    bool IsValidIndex(FVector3i CellIJK) const
    {
        return BlockedGrid3LayoutType::IsValidIJK(CellIJK);
    }
    ElemType GetValueThreadSafe(int32 I, int32 J, int32 K)
    {
        return ReadValueThreadSafe(I, J, K);
    }
 
    ElemType GetValueThreadSafe(const FVector3i& CellIJK)
    {
        return ReadValueThreadSafe(CellIJK.X, CellIJK.Y, CellIJK.Z);
    }
 
    void SetValueThreadSafe(int32 I, int32 J, int32 K, ElemType NewValue)
    {
        WriteValueThreadSafe(I, J, K, [NewValue](ElemType& GridValueInOut) { GridValueInOut = NewValue; });
    }
 
    void SetValueThreadSafe(const FVector3i& CellIJK, ElemType NewValue)
    {
        WriteValueThreadSafe(CellIJK.X, CellIJK.Y, CellIJK.Z, [NewValue](ElemType& GridValueInOut) { GridValueInOut = NewValue; });
    }
 
    template<typename ProcessFunc>
    void ProcessValueThreadSafe(int32 I, int32 J, int32 K, ProcessFunc Func)
    {
        WriteValueThreadSafe(I, J, K, Func);
    }
 
    template<typename ProcessFunc>
    void ProcessValueThreadSafe(const FVector3i& CellIJK, ProcessFunc Func)
    {
        WriteValueThreadSafe(CellIJK.X, CellIJK.Y, CellIJK.Z, Func);
    }
 
    FVector3i ToIndex(int64 LinearIndex) const
    {
        int32 x = (int32)(LinearIndex % (int64)BlockedGrid3LayoutType::Dimensions.X);
        int32 y = (int32)((LinearIndex / (int64)BlockedGrid3LayoutType::Dimensions.X) % (int64)BlockedGrid3LayoutType::Dimensions.Y);
        int32 z = (int32)(LinearIndex / ((int64)BlockedGrid3LayoutType::Dimensions.X * (int64)BlockedGrid3LayoutType::Dimensions.Y));
        return FVector3i(x, y, z);
    }
    int64 ToLinear(int32 X, int32 Y, int32 Z) const
    {
        return (int64)X + (int64)BlockedGrid3LayoutType::Dimensions.X * ((int64)Y + (int64)BlockedGrid3LayoutType::Dimensions.Y * (int64)Z);
    }
    int64 ToLinear(const FVector3i& IJK) const
    {
        return (int64)IJK.X + (int64)BlockedGrid3LayoutType::Dimensions.X * ((int64)IJK.Y + (int64)BlockedGrid3LayoutType::Dimensions.Y * (int64)IJK.Z);
    }
 
 
};
 
typedef TBlockedDenseGrid3<float>  FBlockedDenseGrid3f;
typedef TBlockedDenseGrid3<double> FBlockedDenseGrid3d;
typedef TBlockedDenseGrid3<int>    FBlockedDenseGrid3i;
 
 
} // end namespace UE::Geometry
} // end namespace UE