VolumeGridEmitter3.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_EMITTER3_HPP
#define CUBBYFLOW_VOLUME_GRID_EMITTER3_HPP
 
#include <Core/Emitter/GridEmitter3.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 VolumeGridEmitter3 final : public GridEmitter3
{
 public:
    class Builder;
 
    using ScalarMapper = std::function<double(double, const Vector3D&, double)>;
 
    using VectorMapper =
        std::function<Vector3D(double, const Vector3D&, const Vector3D&)>;
 
    explicit VolumeGridEmitter3(ImplicitSurface3Ptr sourceRegion,
                                bool isOneShot = true);
 
    VolumeGridEmitter3(const VolumeGridEmitter3&) = default;
 
    VolumeGridEmitter3(VolumeGridEmitter3&&) noexcept = default;
 
    ~VolumeGridEmitter3() override = default;
 
    VolumeGridEmitter3& operator=(const VolumeGridEmitter3&) = default;
 
    VolumeGridEmitter3& operator=(VolumeGridEmitter3&&) noexcept = default;
 
    void AddSignedDistanceTarget(const ScalarGrid3Ptr& scalarGridTarget);
 
    void AddStepFunctionTarget(const ScalarGrid3Ptr& scalarGridTarget,
                               double minValue, double maxValue);
 
    void AddTarget(const ScalarGrid3Ptr& scalarGridTarget,
                   const ScalarMapper& customMapper);
 
    void AddTarget(const VectorGrid3Ptr& vectorGridTarget,
                   const VectorMapper& customMapper);
 
    [[nodiscard]] const ImplicitSurface3Ptr& GetSourceRegion() const;
 
    [[nodiscard]] bool GetIsOneShot() const;
 
    [[nodiscard]] static Builder GetBuilder();
 
 private:
    using ScalarTarget = std::tuple<ScalarGrid3Ptr, ScalarMapper>;
    using VectorTarget = std::tuple<VectorGrid3Ptr, VectorMapper>;
 
    void OnUpdate(double currentTimeInSeconds,
                  double timeIntervalInSeconds) override;
 
    void Emit();
 
    ImplicitSurface3Ptr m_sourceRegion;
    std::vector<ScalarTarget> m_customScalarTargets;
    std::vector<VectorTarget> m_customVectorTargets;
    bool m_isOneShot = true;
    bool m_hasEmitted = false;
};
 
using VolumeGridEmitter3Ptr = std::shared_ptr<VolumeGridEmitter3>;
 
class VolumeGridEmitter3::Builder final
{
 public:
    [[nodiscard]] Builder& WithSourceRegion(const Surface3Ptr& sourceRegion);
 
    [[nodiscard]] Builder& WithIsOneShot(bool isOneShot);
 
    [[nodiscard]] VolumeGridEmitter3 Build() const;
 
    [[nodiscard]] VolumeGridEmitter3Ptr MakeShared() const;
 
 private:
    ImplicitSurface3Ptr m_sourceRegion;
    bool m_isOneShot = true;
};
}  // namespace CubbyFlow
 
#endif