Engine.cpp

Go to the documentation of this file.

#include "Engine.hpp"
 
#include "MayaFlux/Buffers/BufferManager.hpp"
#include "MayaFlux/Core/Windowing/WindowManager.hpp"
#include "MayaFlux/Nodes/Generators/Stochastic.hpp"
#include "MayaFlux/Nodes/NodeGraphManager.hpp"
#include "MayaFlux/Vruta/EventManager.hpp"
#include "MayaFlux/Vruta/Scheduler.hpp"
 
#include "MayaFlux/Journal/Archivist.hpp"
 
namespace MayaFlux::Core {
 
//-------------------------------------------------------------------------
// Initialization and Lifecycle
//-------------------------------------------------------------------------
 
Engine::Engine()
    : m_rng(new Nodes::Generator::Stochastics::Random())
{
}
 
Engine::~Engine()
{
    End();
}
 
Engine::Engine(Engine&& other) noexcept
    : m_stream_info(other.m_stream_info)
    , m_graphics_config(other.m_graphics_config)
    , m_is_paused(other.m_is_paused)
    , m_is_initialized(other.m_is_initialized)
    , m_should_shutdown(other.m_should_shutdown.load())
    , m_scheduler(std::move(other.m_scheduler))
    , m_node_graph_manager(std::move(other.m_node_graph_manager))
    , m_buffer_manager(std::move(other.m_buffer_manager))
    , m_subsystem_manager(std::move(other.m_subsystem_manager))
    , m_window_manager(std::move(other.m_window_manager))
    , m_event_manager(std::move(other.m_event_manager))
    , m_rng(std::move(other.m_rng))
{
    other.m_is_initialized = false;
    other.m_is_paused = false;
}
 
Engine& Engine::operator=(Engine&& other) noexcept
{
    if (this != &other) {
        End();
 
        m_stream_info = other.m_stream_info;
        m_graphics_config = other.m_graphics_config;
 
        m_subsystem_manager = std::move(other.m_subsystem_manager);
        m_node_graph_manager = std::move(other.m_node_graph_manager);
        m_buffer_manager = std::move(other.m_buffer_manager);
        m_scheduler = std::move(other.m_scheduler);
        m_window_manager = std::move(other.m_window_manager);
        m_event_manager = std::move(other.m_event_manager);
        m_rng = std::move(other.m_rng);
 
        m_is_initialized = other.m_is_initialized;
        m_is_paused = other.m_is_paused;
        m_should_shutdown = other.m_should_shutdown.load();
 
        other.m_is_initialized = false;
        other.m_is_paused = false;
    }
    return *this;
}
 
void Engine::Init()
{
    Init(m_stream_info, m_graphics_config);
}
 
void Engine::Init(const GlobalStreamInfo& streamInfo)
{
    Init(streamInfo, m_graphics_config);
}
 
void Engine::Init(const GlobalStreamInfo& streamInfo, const GlobalGraphicsConfig& graphics_config)
{
    MF_PRINT(Journal::Component::Core, Journal::Context::Init, "Engine initializing");
    m_stream_info = streamInfo;
    m_graphics_config = graphics_config;
 
    m_scheduler = std::make_shared<Vruta::TaskScheduler>(m_stream_info.sample_rate);
    m_event_manager = std::make_shared<Vruta::EventManager>();
 
    m_buffer_manager = std::make_shared<Buffers::BufferManager>(
        m_stream_info.output.channels,
        m_stream_info.input.enabled ? m_stream_info.input.channels : 0,
        m_stream_info.buffer_size);
 
    m_node_graph_manager = std::make_shared<Nodes::NodeGraphManager>();
 
    if (m_graphics_config.windowing_backend != GlobalGraphicsConfig::WindowingBackend::NONE) {
        m_window_manager = std::make_shared<WindowManager>(m_graphics_config);
    } else {
        MF_WARN(Journal::Component::Core, Journal::Context::Init, "No windowing backend selected - running in audio-only mode");
    }
 
    m_subsystem_manager = std::make_shared<SubsystemManager>(
        m_node_graph_manager, m_buffer_manager, m_scheduler, m_window_manager);
 
    m_subsystem_manager->create_audio_subsystem(m_stream_info, Utils::AudioBackendType::RTAUDIO);
 
    m_subsystem_manager->create_graphics_subsystem(m_graphics_config);
 
    m_buffer_manager->initialize_buffer_service();
 
    m_is_initialized = true;
 
    MF_PRINT(Journal::Component::Core, Journal::Context::Init, "Audio backend: RtAudio, Sample rate: {}", m_stream_info.sample_rate);
}
 
void Engine::Start()
{
    if (!m_is_initialized) {
        Init();
    }
    m_subsystem_manager->start_all_subsystems();
}
 
void Engine::Pause()
{
    if (m_is_paused || !m_is_initialized) {
        return;
    }
 
    m_subsystem_manager->pause_all_subsystems();
    m_is_paused = true;
}
 
void Engine::Resume()
{
    if (!m_is_paused || !m_is_initialized) {
        return;
    }
 
    m_subsystem_manager->resume_all_subsystems();
    m_is_paused = false;
}
 
void Engine::End()
{
    if (m_subsystem_manager) {
        m_subsystem_manager->shutdown();
    }
 
    m_is_initialized = false;
    m_is_paused = false;
 
    if (m_buffer_manager) {
        m_buffer_manager->terminate_active_buffers();
        m_buffer_manager.reset();
    }
 
    if (m_node_graph_manager) {
        for (auto token : m_node_graph_manager->get_active_tokens()) {
            for (auto root : m_node_graph_manager->get_all_root_nodes(token)) {
                if (root != nullptr) {
                    root->clear_all_nodes();
                }
            }
        }
    }
 
    if (m_window_manager) {
        auto windows = m_window_manager->get_windows();
        for (auto& window : windows) {
            m_window_manager->destroy_window(window);
        }
        m_window_manager.reset();
    }
}
 
bool Engine::is_running() const
{
    if (!m_is_initialized || m_is_paused) {
        return false;
    }
 
    if (m_is_initialized) {
        auto status = m_subsystem_manager->query_subsystem_status();
        for (const auto& [type, readiness] : status) {
            const auto& [is_ready, is_running] = readiness;
            if (is_ready && is_running) {
                return true;
            }
        }
    }
    return false;
}
 
} // namespace MayaFlux::Core