VolumeGridEmitter2.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_VOLUME_GRID_EMITTER2_HPP
#define CUBBYFLOW_VOLUME_GRID_EMITTER2_HPP

#include <Core/Emitter/GridEmitter2.hpp>
#include <Core/Geometry/ImplicitSurface.hpp>
#include <Core/Grid/ScalarGrid.hpp>
#include <Core/Grid/VectorGrid.hpp>
#include <Core/Matrix/Matrix.hpp>

#include <memory>

namespace CubbyFlow
{
class VolumeGridEmitter2 final : public GridEmitter2
{
 public:
    class Builder;

    using ScalarMapper = std::function<double(double, const Vector2D&, double)>;

    using VectorMapper =
        std::function<Vector2D(double, const Vector2D&, const Vector2D&)>;

    explicit VolumeGridEmitter2(ImplicitSurface2Ptr sourceRegion,
                                bool isOneShot = true);

    VolumeGridEmitter2(const VolumeGridEmitter2&) = default;

    VolumeGridEmitter2(VolumeGridEmitter2&&) noexcept = default;

    ~VolumeGridEmitter2() override = default;

    VolumeGridEmitter2& operator=(const VolumeGridEmitter2&) = default;

    VolumeGridEmitter2& operator=(VolumeGridEmitter2&&) noexcept = default;

    void AddSignedDistanceTarget(const ScalarGrid2Ptr& scalarGridTarget);

    void AddStepFunctionTarget(const ScalarGrid2Ptr& scalarGridTarget,
                               double minValue, double maxValue);

    void AddTarget(const ScalarGrid2Ptr& scalarGridTarget,
                   const ScalarMapper& customMapper);

    void AddTarget(const VectorGrid2Ptr& vectorGridTarget,
                   const VectorMapper& customMapper);

    [[nodiscard]] const ImplicitSurface2Ptr& GetSourceRegion() const;

    [[nodiscard]] bool GetIsOneShot() const;

    [[nodiscard]] static Builder GetBuilder();

 private:
    using ScalarTarget = std::tuple<ScalarGrid2Ptr, ScalarMapper>;
    using VectorTarget = std::tuple<VectorGrid2Ptr, VectorMapper>;

    void OnUpdate(double currentTimeInSeconds,
                  double timeIntervalInSeconds) override;

    void Emit();

    ImplicitSurface2Ptr m_sourceRegion;
    std::vector<ScalarTarget> m_customScalarTargets;
    std::vector<VectorTarget> m_customVectorTargets;
    bool m_isOneShot = true;
    bool m_hasEmitted = false;
};

using VolumeGridEmitter2Ptr = std::shared_ptr<VolumeGridEmitter2>;

class VolumeGridEmitter2::Builder final
{
 public:
    [[nodiscard]] Builder& WithSourceRegion(const Surface2Ptr& sourceRegion);

    [[nodiscard]] Builder& WithIsOneShot(bool isOneShot);

    [[nodiscard]] VolumeGridEmitter2 Build() const;

    [[nodiscard]] VolumeGridEmitter2Ptr MakeShared() const;

 private:
    ImplicitSurface2Ptr m_sourceRegion;
    bool m_isOneShot = true;
};
}  // namespace CubbyFlow

#endif