WakeBlend.h

#pragma once
 
#include <marenv/wake/WakeField.h>
#include <marenv/wake/WakeTypes.h>
 
#include <atomic>
#include <concepts>
#include <memory>
#include <stdexcept>
 
namespace marenv::wake
{
template<class S>
concept WakeBlendSnapshot = requires(const S& snapshot, double t, const double* pos, WakeSample& out) {
    { snapshot.Sample(t, pos, out) } -> std::convertible_to<bool>;
};
 
template<WakeBlendSnapshot S>
class WakeBlend
{
public:
    struct State
    {
        std::shared_ptr<const S> current; 
        std::shared_ptr<const State> previous; 
        double start; 
        double time; 
    };
 
    using Sum = WakeBlendSum;
 
    static double Weight(double t, double start, double time) { return BlendWeight(t, start, time); }
 
    [[nodiscard]] std::shared_ptr<const State> Load() const { return m_state.load(); }
 
    void Publish(std::shared_ptr<const S> next, double start, double time)
    {
        const auto inUse = Load();
        if (inUse && inUse->start + inUse->time > start)
            throw std::logic_error("WakeBlend::Publish: the previous blend has not ended (R22)");
        auto previous = inUse && time > 0.0 ? Settled(inUse->current) : nullptr;
        Install(std::move(next), std::move(previous), start, time);
    }
 
    static Sum Evaluate(const State& state, double t, const double pos[3])
    {
        Sum sum;
        const double weight = Weight(t, state.start, state.time);
        WakeSample sample {};
        if (weight > 0.0 && state.current->Sample(t, pos, sample))
            sum.Add(weight, sample);
        if (weight < 1.0 && state.previous) {
            const Sum previous = Evaluate(*state.previous, t, pos);
            if (previous.inside)
                sum.Add(1.0 - weight, previous);
        }
        return sum;
    }
 
    static bool Blends(const State& state, double t) { return Weight(t, state.start, state.time) < 1.0; }
 
    static WakeBlendSamples Samples(const State& state, double t, const double pos[3])
    {
        WakeBlendSamples samples;
        samples.currentInside = state.current->Sample(t, pos, samples.current);
        if (state.previous)
            samples.previous = Evaluate(*state.previous, t, pos);
        samples.start = state.start;
        samples.time  = state.time;
        return samples;
    }
 
    static bool MayReach(const State& state, const WakeQueryRegion& region)
    {
        const bool previousSampled = state.previous && Weight(region.tBegin, state.start, state.time) < 1.0;
        return state.current->MayReach(region) || (previousSampled && MayReach(*state.previous, region));
    }
 
private:
    static std::shared_ptr<const State> Settled(std::shared_ptr<const S> snapshot)
    {
        return std::make_shared<const State>(State {std::move(snapshot), nullptr, 0.0, 0.0});
    }
 
    void Install(std::shared_ptr<const S> next, std::shared_ptr<const State> previous, double start, double time)
    {
        m_state.store(std::make_shared<const State>(State {std::move(next), std::move(previous), start, time}));
    }
 
    std::atomic<std::shared_ptr<const State>> m_state; 
};
} // namespace marenv::wake