CUDAParticleSystemData3.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_DATA3_HPP
#define CUBBYFLOW_CUDA_PARTICLE_SYSTEM_DATA3_HPP

#ifdef CUBBYFLOW_USE_CUDA

#include <Core/Array/ArrayView.hpp>
#include <Core/CUDA/CUDAArray.hpp>
#include <Core/CUDA/CUDAPointHashGridSearcher3.hpp>
#include <Core/Matrix/Matrix.hpp>

#include <cuda_runtime.h>

namespace CubbyFlow
{
class CUDAParticleSystemData3
{
 public:
    using IntData = CUDAArray1<int>;

    using FloatData = CUDAArray1<float>;

    using VectorData = CUDAArray1<float4>;

    CUDAParticleSystemData3();

    explicit CUDAParticleSystemData3(size_t numberOfParticles);

    virtual ~CUDAParticleSystemData3() = default;

    CUDAParticleSystemData3(const CUDAParticleSystemData3& other);

    CUDAParticleSystemData3(CUDAParticleSystemData3&& other) noexcept;

    CUDAParticleSystemData3& operator=(const CUDAParticleSystemData3& other);

    CUDAParticleSystemData3& operator=(
        CUDAParticleSystemData3&& 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 Vector4F& initialVal = Vector4F{});

    size_t NumberOfIntData() const;

    size_t NumberOfFloatData() const;

    size_t NumberOfVectorData() const;

    ConstCUDAArrayView1<float4> Positions() const;

    CUDAArrayView1<float4> Positions();

    ConstCUDAArrayView1<float4> Velocities() const;

    CUDAArrayView1<float4> 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<float4> VectorDataAt(size_t idx) const;

    CUDAArrayView1<float4> VectorDataAt(size_t idx);

    void AddParticle(const Vector4F& newPosition,
                     const Vector4F& newVelocity = Vector4F{});

    void AddParticles(
        ConstArrayView1<Vector4F> newPositions,
        ConstArrayView1<Vector4F> newVelocities = ArrayView1<Vector4F>{});

    void AddParticles(
        ConstCUDAArrayView1<float4> newPositions,
        ConstCUDAArrayView1<float4> newVelocities = CUDAArrayView1<float4>{});

    ConstCUDAArrayView1<uint32_t> NeighborStarts() const;

    ConstCUDAArrayView1<uint32_t> NeighborEnds() const;

    const CUDAPointHashGridSearcher3* NeighborSearcher() const;

    ConstCUDAArrayView1<uint32_t> NeighborLists() const;

    void BuildNeighborSearcher(float maxSearchRadius);

    void BuildNeighborLists(float maxSearchRadius);

    void Set(const CUDAParticleSystemData3& other);

 protected:
    CUDAPointHashGridSearcher3Ptr 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 CUDAParticleSystemData3Ptr = std::shared_ptr<CUDAParticleSystemData3>;
}  // namespace CubbyFlow

#endif

#endif