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