CUDAPointHashGridSearcher2.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_CUDA_POINT_HASH_GRID_SEARCHER2_HPP
#define CUBBYFLOW_CUDA_POINT_HASH_GRID_SEARCHER2_HPP
 
#ifdef CUBBYFLOW_USE_CUDA
 
#include <Core/CUDA/CUDAArrayView.hpp>
#include <Core/Matrix/Matrix.hpp>
 
#include <cuda_runtime.h>
 
namespace CubbyFlow
{
class CUDAPointHashGridSearcher2 final
{
 public:
    class Builder;
 
    class HashUtils
    {
     public:
        HashUtils() = default;
 
        inline CUBBYFLOW_CUDA_HOST_DEVICE HashUtils(float gridSpacing,
                                                    uint2 resolution);
 
        inline CUBBYFLOW_CUDA_HOST_DEVICE void GetNearbyKeys(
            float2 position, uint32_t* nearbyKeys) const;
 
        inline CUBBYFLOW_CUDA_HOST_DEVICE int2
        GetBucketIndex(float2 position) const;
 
        inline CUBBYFLOW_CUDA_HOST_DEVICE uint32_t
        GetHashKeyFromBucketIndex(int2 bucketIndex) const;
 
        inline CUBBYFLOW_CUDA_HOST_DEVICE uint32_t
        GetHashKeyFromPosition(float2 position) const;
 
     private:
        float m_gridSpacing;
        uint32_t m_dummy;
        uint2 m_resolution;
    };
 
    template <typename Callback>
    class ForEachNearbyPointFunc
    {
     public:
        inline CUBBYFLOW_CUDA_HOST_DEVICE ForEachNearbyPointFunc(
            float r, float gridSpacing, uint2 resolution, const uint32_t* sit,
            const uint32_t* eit, const uint32_t* si, const float2* p,
            const float2* o, Callback cb);
 
        template <typename Index>
        inline CUBBYFLOW_CUDA_HOST_DEVICE void operator()(Index idx);
 
     private:
        HashUtils m_hashUtils;
        float m_radius;
        const uint32_t* m_startIndexTable;
        const uint32_t* m_endIndexTable;
        const uint32_t* m_sortedIndices;
        const float2* m_points;
        const float2* m_origins;
        Callback m_callback;
    };
 
    CUDAPointHashGridSearcher2(const uint2& resolution, float gridSpacing);
 
    CUDAPointHashGridSearcher2(uint32_t resolutionX, uint32_t resolutionY,
                               float gridSpacing);
 
    CUDAPointHashGridSearcher2(const CUDAPointHashGridSearcher2& other);
 
    CUDAPointHashGridSearcher2(CUDAPointHashGridSearcher2&& other) noexcept;
 
    ~CUDAPointHashGridSearcher2() = default;
 
    CUDAPointHashGridSearcher2& operator=(
        const CUDAPointHashGridSearcher2& other);
 
    CUDAPointHashGridSearcher2& operator=(
        CUDAPointHashGridSearcher2&& other) noexcept;
 
    void Build(const ConstCUDAArrayView1<float2>& points);
 
    template <typename Callback>
    void ForEachNearbyPoint(const ConstCUDAArrayView1<float2>& origins,
                            float radius, Callback callback) const;
 
    float GridSpacing() const;
 
    Vector2UZ Resolution() const;
 
    ConstCUDAArrayView1<float2> SortedPoints() const;
 
    ConstCUDAArrayView1<uint32_t> Keys() const;
 
    ConstCUDAArrayView1<uint32_t> StartIndexTable() const;
 
    ConstCUDAArrayView1<uint32_t> EndIndexTable() const;
 
    ConstCUDAArrayView1<uint32_t> SortedIndices() const;
 
    void Set(const CUDAPointHashGridSearcher2& other);
 
    static Builder GetBuilder();
 
 private:
    float m_gridSpacing = 1.0f;
    uint1 m_dummy;
    uint2 m_resolution = make_uint2(1, 1);
    CUDAArray1<float2> m_points;
    CUDAArray1<uint32_t> m_keys;
    CUDAArray1<uint32_t> m_startIndexTable;
    CUDAArray1<uint32_t> m_endIndexTable;
    CUDAArray1<uint32_t> m_sortedIndices;
};
 
using CUDAPointHashGridSearcher2Ptr =
    std::shared_ptr<CUDAPointHashGridSearcher2>;
 
class CUDAPointHashGridSearcher2::Builder final
{
 public:
    Builder& WithResolution(const Vector2UZ& resolution);
 
    Builder& WithGridSpacing(float gridSpacing);
 
    CUDAPointHashGridSearcher2 Build() const;
 
    CUDAPointHashGridSearcher2Ptr MakeShared() const;
 
 private:
    Vector2UZ m_resolution{ 64, 64 };
    float m_gridSpacing = 1.0f;
};
}  // namespace CubbyFlow
 
#include <Core/CUDA/CUDAPointHashGridSearcher2-Impl.hpp>
 
#endif
 
#endif