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