ParticleSystemData.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_PARTICLE_SYSTEM_DATA_HPP
#define CUBBYFLOW_PARTICLE_SYSTEM_DATA_HPP
 
#include <Core/Array/Array.hpp>
#include <Core/Searcher/PointNeighborSearcher.hpp>
#include <Core/Utils/Serialization.hpp>
 
#ifndef CUBBYFLOW_DOXYGEN
 
namespace flatbuffers
{
class FlatBufferBuilder;
template <typename T>
struct Offset;
}  // namespace flatbuffers
 
namespace CubbyFlow
{
namespace fbs
{
struct ParticleSystemData2;
struct ParticleSystemData3;
}  // namespace fbs
}  // namespace CubbyFlow
 
#endif
 
namespace CubbyFlow
{
template <size_t N>
class ParticleSystemData : public Serializable
{
 public:
    using ScalarData = Array1<double>;
 
    using VectorData = Array1<Vector<double, N>>;
 
    ParticleSystemData();
 
    explicit ParticleSystemData(size_t numberOfParticles);
 
    ~ParticleSystemData() override = default;
 
    ParticleSystemData(const ParticleSystemData& other);
 
    ParticleSystemData(ParticleSystemData&& other) noexcept;
 
    ParticleSystemData& operator=(const ParticleSystemData& other);
 
    ParticleSystemData& operator=(ParticleSystemData&& other) noexcept;
 
    void Resize(size_t newNumberOfParticles);
 
    [[nodiscard]] size_t NumberOfParticles() const;
 
    [[nodiscard]] size_t AddScalarData(double initialVal = 0.0);
 
    [[nodiscard]] size_t AddVectorData(
        const Vector<double, N>& initialVal = Vector<double, N>{});
 
    [[nodiscard]] double Radius() const;
 
    virtual void SetRadius(double newRadius);
 
    [[nodiscard]] double Mass() const;
 
    virtual void SetMass(double newMass);
 
    [[nodiscard]] ConstArrayView1<Vector<double, N>> Positions() const;
 
    [[nodiscard]] ArrayView1<Vector<double, N>> Positions();
 
    [[nodiscard]] ConstArrayView1<Vector<double, N>> Velocities() const;
 
    [[nodiscard]] ArrayView1<Vector<double, N>> Velocities();
 
    [[nodiscard]] ConstArrayView1<Vector<double, N>> Forces() const;
 
    [[nodiscard]] ArrayView1<Vector<double, N>> Forces();
 
    [[nodiscard]] ConstArrayView1<double> ScalarDataAt(size_t idx) const;
 
    [[nodiscard]] ArrayView1<double> ScalarDataAt(size_t idx);
 
    [[nodiscard]] ConstArrayView1<Vector<double, N>> VectorDataAt(
        size_t idx) const;
 
    [[nodiscard]] ArrayView1<Vector<double, N>> VectorDataAt(size_t idx);
 
    void AddParticle(const Vector<double, N>& newPosition,
                     const Vector<double, N>& newVelocity = Vector<double, N>(),
                     const Vector<double, N>& newForce = Vector<double, N>());
 
    void AddParticles(const ConstArrayView1<Vector<double, N>>& newPositions,
                      const ConstArrayView1<Vector<double, N>>& newVelocities =
                          ConstArrayView1<Vector<double, N>>(),
                      const ConstArrayView1<Vector<double, N>>& newForces =
                          ConstArrayView1<Vector<double, N>>());
 
    [[nodiscard]] const std::shared_ptr<PointNeighborSearcher<N>>&
    NeighborSearcher() const;
 
    void SetNeighborSearcher(
        const std::shared_ptr<PointNeighborSearcher<N>>& newNeighborSearcher);
 
    [[nodiscard]] const Array1<Array1<size_t>>& NeighborLists() const;
 
    void BuildNeighborSearcher(double maxSearchRadius);
 
    void BuildNeighborLists(double maxSearchRadius);
 
    void Serialize(std::vector<uint8_t>* buffer) const override;
 
    void Deserialize(const std::vector<uint8_t>& buffer) override;
 
    void Set(const ParticleSystemData& other);
 
 protected:
    template <size_t M = N>
    static std::enable_if_t<M == 2, void> Serialize(
        const ParticleSystemData<2>& particles,
        flatbuffers::FlatBufferBuilder* builder,
        flatbuffers::Offset<fbs::ParticleSystemData2>* fbsParticleSystemData);
 
    template <size_t M = N>
    static std::enable_if_t<M == 3, void> Serialize(
        const ParticleSystemData<3>& particles,
        flatbuffers::FlatBufferBuilder* builder,
        flatbuffers::Offset<fbs::ParticleSystemData3>* fbsParticleSystemData);
 
    template <size_t M = N>
    static std::enable_if_t<M == 2, void> Deserialize(
        const fbs::ParticleSystemData2* fbsParticleSystemData,
        ParticleSystemData<2>& particles);
 
    template <size_t M = N>
    static std::enable_if_t<M == 3, void> Deserialize(
        const fbs::ParticleSystemData3* fbsParticleSystemData,
        ParticleSystemData<3>& particles);
 
 private:
    double m_radius = 1e-3;
    double m_mass = 1e-3;
    size_t m_numberOfParticles = 0;
    size_t m_positionIdx = 0;
    size_t m_velocityIdx = 0;
    size_t m_forceIdx = 0;
 
    Array1<ScalarData> m_scalarDataList;
    Array1<VectorData> m_vectorDataList;
 
    std::shared_ptr<PointNeighborSearcher<N>> m_neighborSearcher;
    Array1<Array1<size_t>> m_neighborLists;
};
 
using ParticleSystemData2 = ParticleSystemData<2>;
 
using ParticleSystemData3 = ParticleSystemData<3>;
 
using ParticleSystemData2Ptr = std::shared_ptr<ParticleSystemData2>;
 
using ParticleSystemData3Ptr = std::shared_ptr<ParticleSystemData3>;
}  // namespace CubbyFlow
 
#endif