start()

Chimera MayaFlux::Kriya::ChimeraBuilder::start

(

)

Start feeding every declared layer on the frame clock.

Returns

The running set, or an empty one if the buffer is null, no layer was declared, or more layers were declared than the buffer holds.

Definition at line 470 of file Chimera.cpp.

{
    Chimera set;
 
    if (!m_buffer || m_layers.empty()) {
        MF_ERROR(Journal::Component::Kriya, Journal::Context::Configuration,
            "ChimeraBuilder::start needs a buffer and at least one layer");
        return set;
    }
 
    if (m_layers.size() > m_buffer->get_layer_count()) {
        MF_ERROR(Journal::Component::Kriya, Journal::Context::Configuration,
            "ChimeraBuilder::start declared {} layers, the buffer holds {}",
            m_layers.size(), m_buffer->get_layer_count());
        return set;
    }
 
    if (!m_pipeline) {
        MF_ERROR(Journal::Component::Kriya, Journal::Context::Configuration,
            "ChimeraBuilder::start needs a pipeline to feed the layers");
        return set;
    }
 
    for (auto& layer : m_layers) {
        if (!layer.piped) {
            continue;
        }
 
        layer.ring = m_pipeline->get_graphics_stream();
        if (!layer.ring) {
            MF_ERROR(Journal::Component::Kriya, Journal::Context::Configuration,
                "ChimeraBuilder::start found no stream in the pipeline for from_pipeline");
            return set;
        }
    }
 
    auto state = std::make_shared<Chimera::State>();
 
    state->buffer = m_buffer;
    state->pipeline = m_pipeline;
    state->layers = m_layers;
    state->frame_rate = std::max(static_cast<double>(Vruta::s_registered_frame_rate), 1.0);
 
    uint32_t index = 0;
    for (const auto& layer : state->layers) {
        m_buffer->set_weight(index, layer.level);
        if (layer.fit) {
            m_buffer->set_layer_fit(index, layer.fit);
        }
        if (layer.params) {
            m_buffer->set_layer_params(index, *layer.params);
        }
        ++index;
    }
 
    if (m_render) {
        m_buffer->setup_rendering(*m_render);
        m_render.reset();
    }
 
    const std::weak_ptr<Chimera::State> weak = state;
    m_pipeline >> BufferOperation::dispatch_to(
        [weak](Kakshya::DataVariant&, uint32_t cycle) {
            if (const auto running = weak.lock()) {
                Chimera::tick(*running, cycle);
            }
        },
        Buffers::ProcessingToken::GRAPHICS_BACKEND);
 
    for (const auto& action : m_actions) {
        const auto cycles = static_cast<uint32_t>(std::max(std::round(action.seconds * state->frame_rate), 1.0));
 
        auto timed = BufferOperation::dispatch_to(
            [weak, run = action.run](Kakshya::DataVariant&, uint32_t cycle) {
                const auto running = weak.lock();
                if (!running || cycle == 0) {
                    return;
                }
 
                Chimera view;
                view.m_state = running;
                run(view);
            },
            Buffers::ProcessingToken::GRAPHICS_BACKEND);
        timed.every_n_cycles(cycles);
 
        m_pipeline >> std::move(timed);
    }
 
    m_pipeline->execute_frame_rate();
 
    set.m_guard = std::shared_ptr<void>(nullptr, [state](void*) { state->halt(); });
    set.m_state = std::move(state);
    return set;
}

References MayaFlux::Journal::Configuration, MayaFlux::Kriya::BufferOperation::dispatch_to(), MayaFlux::Kriya::BufferOperation::every_n_cycles(), fit(), MayaFlux::Buffers::GRAPHICS_BACKEND, index, MayaFlux::Journal::Kriya, layer(), level(), m_actions, m_buffer, m_layers, m_pipeline, m_render, MF_ERROR, params(), run(), and MayaFlux::Vruta::s_registered_frame_rate.

Here is the call graph for this function: