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