GridSystemData.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_GRID_SYSTM_DATA_HPP
#define CUBBYFLOW_GRID_SYSTM_DATA_HPP
 
#include <Core/Grid/FaceCenteredGrid.hpp>
#include <Core/Grid/ScalarGrid.hpp>
#include <Core/Utils/Serialization.hpp>
 
namespace CubbyFlow
{
template <size_t N>
class GridSystemData : public Serializable
{
 public:
    GridSystemData();
 
    GridSystemData(const Vector<size_t, N>& resolution,
                   const Vector<double, N>& gridSpacing,
                   const Vector<double, N>& origin);
 
    ~GridSystemData() override = default;
 
    GridSystemData(const GridSystemData& other);
 
    GridSystemData(GridSystemData&& other) noexcept;
 
    GridSystemData& operator=(const GridSystemData& other);
 
    GridSystemData& operator=(GridSystemData&& other) noexcept;
 
    void Resize(const Vector<size_t, N>& resolution,
                const Vector<double, N>& gridSpacing,
                const Vector<double, N>& origin);
 
    [[nodiscard]] Vector<size_t, N> Resolution() const;
 
    [[nodiscard]] Vector<double, N> GridSpacing() const;
 
    [[nodiscard]] Vector<double, N> Origin() const;
 
    [[nodiscard]] BoundingBox<double, N> GetBoundingBox() const;
 
    size_t AddScalarData(const std::shared_ptr<ScalarGridBuilder<N>>& builder,
                         double initialVal = 0.0);
 
    size_t AddVectorData(
        const std::shared_ptr<VectorGridBuilder<N>>& builder,
        const Vector<double, N>& initialVal = Vector<double, N>{});
 
    size_t AddAdvectableScalarData(
        const std::shared_ptr<ScalarGridBuilder<N>>& builder,
        double initialVal = 0.0);
 
    size_t AddAdvectableVectorData(
        const std::shared_ptr<VectorGridBuilder<N>>& builder,
        const Vector<double, N>& initialVal = Vector<double, N>{});
 
    [[nodiscard]] const std::shared_ptr<FaceCenteredGrid<N>>& Velocity() const;
 
    [[nodiscard]] size_t VelocityIndex() const;
 
    [[nodiscard]] const std::shared_ptr<ScalarGrid<N>>& ScalarDataAt(
        size_t idx) const;
 
    [[nodiscard]] const std::shared_ptr<VectorGrid<N>>& VectorDataAt(
        size_t idx) const;
 
    [[nodiscard]] const std::shared_ptr<ScalarGrid<N>>& AdvectableScalarDataAt(
        size_t idx) const;
 
    [[nodiscard]] const std::shared_ptr<VectorGrid<N>>& AdvectableVectorDataAt(
        size_t idx) const;
 
    [[nodiscard]] size_t NumberOfScalarData() const;
 
    [[nodiscard]] size_t NumberOfVectorData() const;
 
    [[nodiscard]] size_t NumberOfAdvectableScalarData() const;
 
    [[nodiscard]] size_t NumberOfAdvectableVectorData() const;
 
    void Serialize(std::vector<uint8_t>* buffer) const override;
 
    void Deserialize(const std::vector<uint8_t>& buffer) override;
 
 private:
    template <size_t M = N>
    static std::enable_if_t<M == 2, void> Serialize(
        const GridSystemData<2>& grid, std::vector<uint8_t>* buffer);
 
    template <size_t M = N>
    static std::enable_if_t<M == 3, void> Serialize(
        const GridSystemData<3>& grid, std::vector<uint8_t>* buffer);
 
    template <size_t M = N>
    static std::enable_if_t<M == 2, void> Deserialize(
        const std::vector<uint8_t>& buffer, GridSystemData<2>& grid);
 
    template <size_t M = N>
    static std::enable_if_t<M == 3, void> Deserialize(
        const std::vector<uint8_t>& buffer, GridSystemData<3>& grid);
 
    Vector<size_t, N> m_resolution;
    Vector<double, N> m_gridSpacing;
    Vector<double, N> m_origin;
 
    std::shared_ptr<FaceCenteredGrid<N>> m_velocity;
    size_t m_velocityIdx = 0;
    std::vector<std::shared_ptr<ScalarGrid<N>>> m_scalarDataList;
    std::vector<std::shared_ptr<VectorGrid<N>>> m_vectorDataList;
    std::vector<std::shared_ptr<ScalarGrid<N>>> m_advectableScalarDataList;
    std::vector<std::shared_ptr<VectorGrid<N>>> m_advectableVectorDataList;
};
 
using GridSystemData2 = GridSystemData<2>;
 
using GridSystemData3 = GridSystemData<3>;
 
using GridSystemData2Ptr = std::shared_ptr<GridSystemData2>;
 
using GridSystemData3Ptr = std::shared_ptr<GridSystemData3>;
}  // namespace CubbyFlow
 
#endif