WakeSelection.h

#pragma once
 
#include <marenv/WaterVelocity.h> // WaterVelocityParts
#include <marenv/wake/JetField.h>
#include <marenv/wake/WakeField.h>
#include <marenv/wake/WakeSampleParts.h>
#include <marenv/wake/WakeTypes.h> // WakeComposition
 
#include <array>
#include <cstddef>
#include <functional>
#include <memory>
#include <span>
#include <vector>
 
namespace marenv::wake
{
struct WakeQuery
{
    const WakeField* exclude   = nullptr; 
    const WakeField* own       = nullptr; 
    const JetField* excludeJet = nullptr; 
    std::span<const int> ownExcludedTags {}; 
};
 
WakeQueryRegion EnclosingRegion(std::span<const std::array<double, 3>> positions, double time, double cutoff = 0.0);
 
using OwnTagsAt = std::function<std::span<const int>(std::size_t point)>;
 
class HeldWakes
{
public:
    const WakeComposition& At(std::size_t point, double t) const;
 
    WakeComposition At(std::size_t point, double t, const WakeSample& own) const;
 
    std::size_t NumPoints() const { return m_compositions.size(); }
 
    int NumFields() const { return static_cast<int>(m_numFields); }
 
    int NumJets() const { return static_cast<int>(m_numJets); }
 
private:
    friend class WakeSelection;
 
    WakeComposition Compose(std::size_t point, double t, const WakeSample* own) const;
 
    std::size_t m_numFields = 0; 
    std::size_t m_numJets   = 0; 
    bool m_hasOwn           = false; 
    bool m_blending         = false; 
    std::vector<WakeSampleParts> m_parts; 
    std::vector<JetSampleParts> m_jetParts; 
    mutable std::vector<WakeComposition> m_compositions; 
};
 
class WakeSelection
{
public:
    WakeComposition Compose(double t, const double pos[3]) const;
 
    void ComposeMany(double t, std::span<const std::array<double, 3>> positions, std::span<WakeComposition> out) const;
 
    HeldWakes Hold(double t, std::span<const std::array<double, 3>> positions, const OwnTagsAt& ownTags = {}) const;
 
    int NumFields() const { return static_cast<int>(m_fields.size()); }
 
    int NumJets() const { return static_cast<int>(m_jets.size()); }
 
private:
    friend class WakeRegistry;
 
    WakeSelection(std::vector<std::shared_ptr<const WakeField>> fields, std::vector<std::shared_ptr<const JetField>> jets, const WakeQuery& query, const WaterVelocityParts& parts);
 
    std::vector<std::shared_ptr<const WakeField>> m_owned; 
    std::vector<std::shared_ptr<const JetField>> m_ownedJets; 
    std::vector<const WakeField*> m_fields; 
    std::vector<const JetField*> m_jets; 
    WakeQuery m_query; 
    WaterVelocityParts m_parts; 
};
} // namespace marenv::wake