WakeBlend.h

#pragma once
 
#include <marenv/AtomicSharedPtr.h>
#include <marenv/wake/WakeField.h>
#include <marenv/wake/WakeTypes.h>
 
#include <atomic>
#include <concepts>
#include <cstdint>
#include <memory>
#include <stdexcept>
 
namespace marenv::wake
{
template<class S, class Value>
concept BlendSnapshot = requires(const S& snapshot, double t, const double* pos, Value& out) {
    { snapshot.Sample(t, pos, out) } -> std::convertible_to<bool>;
};
 
template<class S>
concept WakeBlendSnapshot = BlendSnapshot<S, WakeSample>;
 
template<class S, class Value = WakeSample, class SumType = WakeBlendSum, class SamplesType = WakeBlendSamples>
    requires BlendSnapshot<S, Value>
class WakeBlend
{
public:
    struct State
    {
        std::shared_ptr<const S> current; 
        std::shared_ptr<const State> previous; 
        double start; 
        double time; 
    };
 
    using Sum = SumType;
 
    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])
    {
        return Evaluate(state, t, pos, SampleSnapshot);
    }
 
    template<class Sampler>
    static Sum Evaluate(const State& state, double t, const double pos[3], const Sampler& sample)
    {
        Sum sum;
        const double weight = Weight(t, state.start, state.time);
        Value value {};
        if (weight > 0.0 && sample(*state.current, t, pos, value))
            sum.Add(weight, value);
        if (weight < 1.0 && state.previous) {
            const Sum previous = Evaluate(*state.previous, t, pos, sample);
            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; }
 
    [[nodiscard]] std::uint64_t Revision() const { return m_revision.load(std::memory_order_acquire); }
 
    bool StaticFrom(double t) const
    {
        const auto state = Load();
        return !state || (!Blends(*state, t) && state->current->Stationary());
    }
 
    static SamplesType Samples(const State& state, double t, const double pos[3])
    {
        return Samples(state, t, pos, SampleSnapshot);
    }
 
    template<class Sampler>
    static SamplesType Samples(const State& state, double t, const double pos[3], const Sampler& sample)
    {
        SamplesType samples;
        samples.currentInside = sample(*state.current, t, pos, samples.current);
        if (state.previous)
            samples.previous = Evaluate(*state.previous, t, pos, sample);
        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 bool SampleSnapshot(const S& snapshot, double t, const double pos[3], Value& out) { return snapshot.Sample(t, pos, out); }
 
    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}));
        m_revision.fetch_add(1, std::memory_order_release);
    }
 
    AtomicSharedPtr<const State> m_state; 
    std::atomic<std::uint64_t> m_revision {0}; 
};
} // namespace marenv::wake