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