binding.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/state/store.hpp>
#include <pulp/state/edit_history.hpp>
#include <functional>
#include <vector>
#include <cmath>
 
namespace pulp::state {

class Binding {
public:
    Binding() = default;

    Binding(StateStore& store, ParamID param_id)
        : store_(&store), param_id_(param_id) {}

    float get() const {
        return store_ ? store_->get_value(param_id_) : 0.0f;
    }

    void set(float value) {
        if (!store_) return;
        float old_value = store_->get_value(param_id_);
        store_->set_value(param_id_, value);
        float new_value = store_->get_value(param_id_); // clamped
        if (std::abs(new_value - old_value) > 1e-7f) {
            notify(new_value);
        }
    }

    float get_normalized() const {
        return store_ ? store_->get_normalized(param_id_) : 0.0f;
    }

    void set_normalized(float normalized) {
        if (!store_) return;
        float old_value = store_->get_value(param_id_);
        store_->set_normalized(param_id_, normalized);
        float new_value = store_->get_value(param_id_);
        if (std::abs(new_value - old_value) > 1e-7f) {
            notify(new_value);
        }
    }

    void begin_gesture() {
        if (store_) {
            gesture_start_value_ = store_->get_value(param_id_);
            store_->begin_gesture(param_id_);
        }
    }

    void end_gesture() {
        if (store_) {
            store_->end_gesture(param_id_);
            // Push to edit history if available
            float end_value = store_->get_value(param_id_);
            if (edit_history_ && std::abs(end_value - gesture_start_value_) > 1e-7f) {
                auto pid = param_id_;
                auto* s = store_;
                float sv = gesture_start_value_;
                float ev = end_value;
                edit_history_->perform(
                    [s, pid, ev]() { s->set_value(pid, ev); },
                    [s, pid, sv]() { s->set_value(pid, sv); },
                    info() ? info()->name : "param change");
            }
        }
    }

    void set_from_background(float value) {
        if (!store_) return;
        store_->run_gesture_on_main([s = store_, pid = param_id_, value] {
            s->begin_gesture(pid);
            s->set_value(pid, value);
            s->end_gesture(pid);
        });
    }

    void set_edit_history(state::EditHistory* h) { edit_history_ = h; }
    state::EditHistory* edit_history() const { return edit_history_; }

    const ParamInfo* info() const {
        return store_ ? store_->info(param_id_) : nullptr;
    }

    ParamID id() const { return param_id_; }

    using ChangeCallback = std::function<void(float new_value)>;

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

    bool poll() {
        if (!store_) return false;
        float current = store_->get_value(param_id_);
        if (std::abs(current - last_polled_) > 1e-7f) {
            last_polled_ = current;
            notify(current);
            return true;
        }
        return false;
    }

    void reset() {
        if (store_ && info()) {
            store_->reset_to_default(param_id_);
            notify(store_->get_value(param_id_));
        }
    }

    bool is_bound() const { return store_ != nullptr; }
 
private:
    void notify(float value) {
        for (auto& cb : callbacks_) {
            if (cb) cb(value);
        }
    }
 
    StateStore* store_ = nullptr;
    ParamID param_id_ = 0;
    float last_polled_ = 0.0f;
    float gesture_start_value_ = 0.0f;
    state::EditHistory* edit_history_ = nullptr;
    std::vector<ChangeCallback> callbacks_;
};

inline std::vector<Binding> create_bindings(StateStore& store) {
    std::vector<Binding> bindings;
    for (const auto& param : store.all_params()) {
        bindings.emplace_back(store, param.id);
    }
    return bindings;
}
 
} // namespace pulp::state