finalise()

void MayaFlux::Nexus::Wiring::finalise

(

)

Apply the configured wiring.

Resolves the builder state into a coroutine (if any scheduling modifier was set) or an immediate call (if bind was used), and registers the result with Fabric.

Definition at line 276 of file Wiring.cpp.

{
    auto& scheduler = m_fabric.m_scheduler;
    auto& ev_manager = m_fabric.m_event_manager;
    const uint32_t id = m_entity_id;
    auto& reg = m_fabric.m_registrations[id];
 
    bool has_any_path = !std::holds_alternative<std::monostate>(m_factory)
        || m_event_factory.has_value()
        || m_bind_attach.has_value()
        || !m_move_steps.empty()
        || !std::holds_alternative<std::monostate>(m_trigger)
        || m_interval.has_value();
 
    reg.commit_driven = !has_any_path;
 
    // ------------------------------------------------------------------
    // Register named callables before any early return.
    // ------------------------------------------------------------------
    std::visit([&](const auto& ptr) {
        using T = std::decay_t<decltype(*ptr)>;
        if constexpr (std::is_same_v<T, Emitter>) {
            if (!ptr->fn_name().empty()) {
                m_fabric.m_influence_fns.try_emplace(
                    ptr->fn_name(), std::make_shared<Emitter::InfluenceFn>(ptr->fn()));
            }
        } else if constexpr (std::is_same_v<T, Sensor>) {
            if (!ptr->fn_name().empty()) {
                m_fabric.m_perception_fns.try_emplace(
                    ptr->fn_name(), std::make_shared<Sensor::PerceptionFn>(ptr->fn()));
            }
        } else if constexpr (std::is_same_v<T, Agent>) {
            if (!ptr->influence_fn_name().empty()) {
                m_fabric.m_influence_fns.try_emplace(
                    ptr->influence_fn_name(), std::make_shared<Emitter::InfluenceFn>(ptr->influence_fn()));
            }
            if (!ptr->perception_fn_name().empty()) {
                m_fabric.m_perception_fns.try_emplace(
                    ptr->perception_fn_name(), std::make_shared<Sensor::PerceptionFn>(ptr->perception_fn()));
            }
        }
    },
        reg.member);
 
    // ------------------------------------------------------------------
    // Routine factory path
    // ------------------------------------------------------------------
    if (!std::holds_alternative<std::monostate>(m_factory)) {
        auto name = make_name("nexus_task");
        reg.task_name = name;
        std::visit([&](auto& factory) {
            using F = std::decay_t<decltype(factory)>;
            if constexpr (!std::is_same_v<F, std::monostate>) {
                scheduler.add_task(
                    std::make_shared<std::invoke_result_t<F>>(factory()),
                    name, false);
            }
        },
            m_factory);
        m_fabric.m_registrations[m_entity_id].wiring.emplace(std::move(*this));
        return;
    }
 
    // ------------------------------------------------------------------
    // Event factory path
    // ------------------------------------------------------------------
    if (m_event_factory.has_value()) {
        auto name = make_name("nexus_event");
        reg.event_name = name;
        ev_manager.add_event(
            std::make_shared<Vruta::Event>((*m_event_factory)(scheduler)),
            name);
        m_fabric.m_registrations[m_entity_id].wiring.emplace(std::move(*this));
        return;
    }
 
    // ------------------------------------------------------------------
    // Immediate bind path
    // ------------------------------------------------------------------
    if (m_bind_attach.has_value()) {
        (*m_bind_attach)();
 
        if (m_duration.has_value() && m_bind_detach.has_value()) {
            auto timer = std::make_shared<Kriya::Timer>(scheduler, m_duration_token);
            auto detach = *m_bind_detach;
            timer->schedule(*m_duration, [timer, detach]() {
                detach();
            });
        }
        m_fabric.m_registrations[m_entity_id].wiring.emplace(std::move(*this));
        return;
    }
 
    // ------------------------------------------------------------------
    // Choreographed position path
    // ------------------------------------------------------------------
    if (!m_move_steps.empty()) {
        auto name = make_name("nexus_chain");
        reg.chain_name = name;
 
        Kriya::EventChain chain(scheduler, name);
        auto& fab = m_fabric;
        for (auto& step : m_move_steps) {
            glm::vec3 pos = step.position;
            chain.then([&fab, pos, id]() {
                std::visit([&pos](const auto& ptr) {
                    ptr->set_position(pos);
                },
                    fab.m_registrations[id].member);
                fab.fire(id);
            },
                step.delay_seconds);
        }
        if (m_times > 1) {
            chain.times(m_times);
        }
        chain.start();
        m_fabric.m_registrations[m_entity_id].wiring.emplace(std::move(*this));
        return;
    }
 
    // ------------------------------------------------------------------
    // Trigger path
    // ------------------------------------------------------------------
    if (!std::holds_alternative<std::monostate>(m_trigger)) {
        std::visit([&](auto& trig) {
            using T = std::decay_t<decltype(trig)>;
 
            if constexpr (std::is_same_v<T, KeyTrigger>) {
                auto name = make_name("nexus_event");
                reg.event_name = name;
                auto& fab = m_fabric;
                ev_manager.add_event(
                    std::make_shared<Vruta::Event>(
                        trig.held
                            ? Kriya::key_held(trig.window, trig.key,
                                  [&fab, id]() { fab.fire(id); })
                            : Kriya::key_pressed(trig.window, trig.key,
                                  [&fab, id]() { fab.fire(id); })),
                    name);
 
                if (trig.on_release) {
                    auto release_name = make_name("nexus_event_release");
                    reg.chain_name = release_name;
                    ev_manager.add_event(
                        std::make_shared<Vruta::Event>(
                            Kriya::key_released(trig.window, trig.key, *trig.on_release)),
                        release_name);
                }
 
            } else if constexpr (std::is_same_v<T, MouseTrigger>) {
                auto name = make_name("nexus_event");
                reg.event_name = name;
                Fabric& fab = m_fabric;
                uint32_t eid = m_entity_id;
                ev_manager.add_event(
                    std::make_shared<Vruta::Event>(
                        trig.held
                            ? Kriya::mouse_dragged(trig.window, trig.button,
                                  [&fab, eid](double px, double py) {
                                      fab.m_registrations[eid].pending_cursor = glm::vec2(px, py);
                                      fab.fire(eid);
                                  })
                            : Kriya::mouse_pressed(trig.window, trig.button,
                                  [&fab, eid](double px, double py) {
                                      fab.m_registrations[eid].pending_cursor = glm::vec2(px, py);
                                      fab.fire(eid);
                                  })),
                    name);
                if (trig.on_release) {
                    auto release_name = make_name("nexus_event_release");
                    reg.chain_name = release_name;
                    ev_manager.add_event(
                        std::make_shared<Vruta::Event>(
                            Kriya::mouse_released(trig.window, trig.button, *trig.on_release)),
                        release_name);
                }
 
            } else if constexpr (std::is_same_v<T, ScrollTrigger>) {
                auto name = make_name("nexus_scroll");
                reg.event_name = name;
                ev_manager.add_event(
                    std::make_shared<Vruta::Event>(
                        scroll_loop(trig.window, trig.fn)),
                    name);
 
            } else if constexpr (std::is_same_v<T, NetworkTrigger>) {
                auto name = make_name("nexus_task");
                reg.task_name = name;
                scheduler.add_task(
                    std::make_shared<Vruta::SoundRoutine>(
                        network_loop(*trig.source, m_fabric, id)),
                    name, false);
 
            } else if constexpr (std::is_same_v<T, WindowEventTrigger>) {
                auto name = make_name("nexus_event");
                reg.event_name = name;
                Fabric& fab = m_fabric;
                ev_manager.add_event(
                    std::make_shared<Vruta::Event>(
                        window_event_source_loop(*trig.source, trig.filter, fab, id)),
                    name);
            }
        },
            m_trigger);
        m_fabric.m_registrations[m_entity_id].wiring.emplace(std::move(*this));
        return;
    }
 
    // ------------------------------------------------------------------
    // Metro path
    // ------------------------------------------------------------------
    if (m_interval.has_value()) {
        auto pos_fn = m_position_fn;
        auto name = make_name("nexus_metro");
        reg.task_name = name;
        auto& fab = m_fabric;
 
        scheduler.add_task(
            Kriya::metro(*m_interval, [&fab, id, pos_fn]() mutable {
                if (pos_fn.has_value()) {
                    glm::vec3 p = (*pos_fn)();
                    std::visit([&p](const auto& ptr) {
                        ptr->set_position(p);
                    },
                        fab.m_registrations[id].member);
                }
                fab.fire(id); }, m_metro_token), name, false);
 
        if (m_duration.has_value()) {
            auto cancel_name = make_name("nexus_metro_cancel");
            auto timer = std::make_shared<Kriya::Timer>(scheduler);
            timer->schedule(*m_duration, [name, timer, &scheduler]() {
                scheduler.cancel_task(name);
            });
        }
    }
 
    m_fabric.m_registrations[m_entity_id].wiring.emplace(std::move(*this));
}

References factory(), MayaFlux::Kriya::key_held(), MayaFlux::Kriya::key_pressed(), MayaFlux::Kriya::key_released(), m_bind_attach, m_bind_detach, m_duration, m_duration_token, m_entity_id, m_event_factory, MayaFlux::Nexus::Fabric::m_event_manager, m_fabric, m_factory, MayaFlux::Nexus::Fabric::m_influence_fns, m_interval, m_metro_token, m_move_steps, MayaFlux::Nexus::Fabric::m_perception_fns, m_position_fn, MayaFlux::Nexus::Fabric::m_registrations, MayaFlux::Nexus::Fabric::m_scheduler, m_times, m_trigger, make_name(), MayaFlux::Kriya::metro(), MayaFlux::Kriya::mouse_dragged(), MayaFlux::Kriya::mouse_pressed(), MayaFlux::Kriya::mouse_released(), ptr, and window_event_source_loop().

Here is the call graph for this function: