external_binding.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/state/parameter.hpp>  // ParamRange
 
#include <cmath>
#include <functional>
#include <string>
#include <utility>
#include <vector>
 
namespace pulp::state {

struct ExternalBindingConfig {
    std::function<float()> get{};
    std::function<void(float)> set{};
    ParamRange range{};
    std::function<void()> begin_gesture{};
    std::function<void()> end_gesture{};
    std::string name{};
    std::string unit{};
};

class ExternalBinding {
public:
    using ChangeCallback = std::function<void(float new_value)>;
 
    ExternalBinding() = default;
 
    explicit ExternalBinding(ExternalBindingConfig cfg)
        : cfg_(std::move(cfg)), last_polled_(cfg_.get ? cfg_.get() : 0.0f) {}

    float get() const { return cfg_.get ? cfg_.get() : 0.0f; }

    void set(float value) {
        if (!cfg_.set) return;
        const float old_value = get();
        cfg_.set(value);
        const float new_value = get();
        if (std::abs(new_value - old_value) > 1e-7f) {
            last_polled_ = new_value;
            fire(new_value);
        }
    }

    float get_normalized() const { return cfg_.range.normalize(get()); }

    void set_normalized(float normalized) { set(cfg_.range.denormalize(normalized)); }

    void begin_gesture() { if (cfg_.begin_gesture) cfg_.begin_gesture(); }
    void end_gesture() { if (cfg_.end_gesture) cfg_.end_gesture(); }

    void on_change(ChangeCallback cb) { callbacks_.push_back(std::move(cb)); }

    bool poll() {
        const float current = get();
        if (std::abs(current - last_polled_) > 1e-7f) {
            last_polled_ = current;
            fire(current);
            return true;
        }
        return false;
    }

    void notify() {
        const float current = get();
        last_polled_ = current;
        fire(current);
    }

    void reset() { set(cfg_.range.default_value); }
 
    const std::string& name() const { return cfg_.name; }
    const std::string& unit() const { return cfg_.unit; }
    const ParamRange& range() const { return cfg_.range; }

    bool is_bound() const { return static_cast<bool>(cfg_.get); }
 
private:
    void fire(float value) {
        if (firing_) return;
        firing_ = true;
        // Reset the guard even if a callback throws — a thrown host callback
        // must not permanently wedge every future notification.
        struct ResetOnExit {
            bool& f;
            ~ResetOnExit() { f = false; }
        } reset_guard{firing_};
 
        // Bounded reconciliation: a reentrant set()/notify() from inside a
        // callback writes the real value through but has its own (nested) fire()
        // suppressed by the guard. Without this loop, listeners would be left on
        // the stale first value while last_polled_ already tracked the new one,
        // so a later poll() could never correct them. Re-dispatch until the
        // observed value stops moving (capped against a pathological oscillator).
        float dispatched = value;
        for (int pass = 0; pass < 8; ++pass) {
            for (auto& cb : callbacks_) {
                if (cb) cb(dispatched);
            }
            const float current = cfg_.get ? cfg_.get() : dispatched;
            if (std::abs(current - dispatched) <= 1e-7f) break;
            dispatched = current;
            last_polled_ = current;
        }
    }
 
    ExternalBindingConfig cfg_{};
    float last_polled_ = 0.0f;
    bool firing_ = false;
    std::vector<ChangeCallback> callbacks_;
};
 
} // namespace pulp::state