CUDAParticleSystemData2.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_PARTICLE_SYSTEM_DATA2_HPP
#define CUBBYFLOW_CUDA_PARTICLE_SYSTEM_DATA2_HPP
 
#ifdef CUBBYFLOW_USE_CUDA
 
#include <Core/Array/ArrayView.hpp>
#include <Core/CUDA/CUDAArray.hpp>
#include <Core/CUDA/CUDAPointHashGridSearcher2.hpp>
#include <Core/Matrix/Matrix.hpp>
 
#include <cuda_runtime.h>
 
namespace CubbyFlow
{
class CUDAParticleSystemData2
{
 public:
    using IntData = CUDAArray1<int>;
 
    using FloatData = CUDAArray1<float>;
 
    using VectorData = CUDAArray1<float2>;
 
    CUDAParticleSystemData2();
 
    explicit CUDAParticleSystemData2(size_t numberOfParticles);
 
    virtual ~CUDAParticleSystemData2() = default;
 
    CUDAParticleSystemData2(const CUDAParticleSystemData2& other);
 
    CUDAParticleSystemData2(CUDAParticleSystemData2&& other) noexcept;
 
    CUDAParticleSystemData2& operator=(const CUDAParticleSystemData2& other);
 
    CUDAParticleSystemData2& operator=(
        CUDAParticleSystemData2&& other) noexcept;
 
    void Resize(size_t newNumberOfParticles);
 
    size_t NumberOfParticles() const;
 
    size_t AddIntData(int initialVal = 0);
 
    size_t AddFloatData(float initialVal = 0.0f);
 
    size_t AddVectorData(const Vector2F& initialVal = Vector2F{});
 
    size_t NumberOfIntData() const;
 
    size_t NumberOfFloatData() const;
 
    size_t NumberOfVectorData() const;
 
    ConstCUDAArrayView1<float2> Positions() const;
 
    CUDAArrayView1<float2> Positions();
 
    ConstCUDAArrayView1<float2> Velocities() const;
 
    CUDAArrayView1<float2> Velocities();
 
    ConstCUDAArrayView1<int> IntDataAt(size_t idx) const;
 
    CUDAArrayView1<int> IntDataAt(size_t idx);
 
    ConstCUDAArrayView1<float> FloatDataAt(size_t idx) const;
 
    CUDAArrayView1<float> FloatDataAt(size_t idx);
 
    ConstCUDAArrayView1<float2> VectorDataAt(size_t idx) const;
 
    CUDAArrayView1<float2> VectorDataAt(size_t idx);
 
    void AddParticle(const Vector2F& newPosition,
                     const Vector2F& newVelocity = Vector2F{});
 
    void AddParticles(
        ConstArrayView1<Vector2F> newPositions,
        ConstArrayView1<Vector2F> newVelocities = ArrayView1<Vector2F>{});
 
    void AddParticles(
        ConstCUDAArrayView1<float2> newPositions,
        ConstCUDAArrayView1<float2> newVelocities = CUDAArrayView1<float2>{});
 
    ConstCUDAArrayView1<uint32_t> NeighborStarts() const;
 
    ConstCUDAArrayView1<uint32_t> NeighborEnds() const;
 
    const CUDAPointHashGridSearcher2* NeighborSearcher() const;
 
    ConstCUDAArrayView1<uint32_t> NeighborLists() const;
 
    void BuildNeighborSearcher(float maxSearchRadius);
 
    void BuildNeighborLists(float maxSearchRadius);
 
    void Set(const CUDAParticleSystemData2& other);
 
 protected:
    CUDAPointHashGridSearcher2Ptr m_neighborSearcher;
    CUDAArray1<uint32_t> m_neighborStarts;
    CUDAArray1<uint32_t> m_neighborEnds;
    CUDAArray1<uint32_t> m_neighborLists;
 
 private:
    size_t m_numberOfParticles = 0;
    size_t m_positionIdx;
    size_t m_velocityIdx;
 
    std::vector<IntData> m_intDataList;
    std::vector<FloatData> m_floatDataList;
    std::vector<VectorData> m_vectorDataList;
};
 
using CUDAParticleSystemData2Ptr = std::shared_ptr<CUDAParticleSystemData2>;
}  // namespace CubbyFlow
 
#endif
 
#endif