set_operator()

void MayaFlux::Nodes::Network::ParticleNetwork::set_operator

(

std::unique_ptr< NetworkOperator >

op

)

Set active operator (runtime switching)

Definition at line 199 of file ParticleNetwork.cpp.

{
    if (!op) {
        MF_ERROR(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "Cannot set null operator");
        return;
    }
 
    if (!is_compatible(*op)) {
        MF_ERROR(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "ParticleNetwork: unsupported operator type '{}' rejected as primary. "
            "The primary must own PointVertex storage; a chain operator need not.",
            op->get_type_name());
        return;
    }
 
    const char* old_name = m_operator ? m_operator->get_type_name().data() : "none";
    const char* new_name = op->get_type_name().data();
 
    MF_INFO(Journal::Component::Nodes, Journal::Context::NodeProcessing,
        "Switching operator: '{}' → '{}'",
        old_name, new_name);
 
    std::vector<PointVertex> vertices;
 
    if (auto* old_graphics = dynamic_cast<PhysicsOperator*>(m_operator.get())) {
        vertices = old_graphics->extract_vertices();
 
        MF_DEBUG(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "Extracted {} vertices from old operator",
            vertices.size());
    } else if (auto* old_field = dynamic_cast<FieldOperator*>(m_operator.get())) {
        vertices = old_field->extract_point_vertices();
 
        MF_DEBUG(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "Extracted {} vertices from old FieldOperator",
            vertices.size());
    } else if (!m_operator) {
        vertices = generate_initial_vertices();
    }
 
    if (auto* new_graphics = dynamic_cast<PhysicsOperator*>(op.get())) {
        new_graphics->initialize(vertices);
 
        if (auto* physics = dynamic_cast<PhysicsOperator*>(op.get())) {
            physics->set_bounds(m_bounds.min, m_bounds.max);
        }
 
        MF_DEBUG(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "Initialized new graphics operator with {} points",
            vertices.size());
    }
 
    if (auto* new_field = dynamic_cast<FieldOperator*>(op.get())) {
        new_field->initialize(vertices);
 
        MF_DEBUG(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "Initialized new FieldOperator with {} points",
            vertices.size());
    }
 
    m_operator = std::move(op);
 
    if (auto* physics = dynamic_cast<PhysicsOperator*>(m_operator.get())) {
        bool should_interact = topology_interacts(get_topology());
        physics->enable_spatial_interactions(should_interact);
    }
 
    MF_INFO(Journal::Component::Nodes, Journal::Context::NodeProcessing,
        "Operator switched successfully to '{}'", new_name);
}

References generate_initial_vertices(), MayaFlux::Nodes::Network::NodeNetwork::get_topology(), is_compatible(), m_bounds, m_operator, MayaFlux::Kinesis::SamplerBounds::max, MF_DEBUG, MF_ERROR, MF_INFO, MayaFlux::Kinesis::SamplerBounds::min, MayaFlux::Journal::NodeProcessing, and MayaFlux::Journal::Nodes.

Here is the call graph for this function: