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