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