wire_field_operators()

void MayaFlux::Buffers::NetworkGeometryBuffer::wire_field_operators ( )

private

Find the first GpuFieldOperator in the network's operator chain and wire its compute stages: a VertexFieldProcessor when it carries bindings, plus whichever spatial-hash / claim / density / population stages its SpatialFieldConfig calls for.

No-op unless the network is one of the field-compatible types (ParticleNetwork, PointCloudNetwork); mesh and instance buffers never reach the scan. Called at the end of setup_processors, so a scene that puts a GpuFieldOperator in the chain needs no hand-wired VertexFieldProcessor and must not add one itself. Implemented in NetworkGeometryFieldWiring.cpp to keep the compute-processor headers out of the base translation unit.

Definition at line 76 of file NetworkGeometryFieldWiring.cpp.

{
    if (!is_field_compatible_network(m_network.get())) {
        return;
    }
 
    auto op_chain = m_network ? m_network->get_operator_chain() : nullptr;
    if (!op_chain) {
        return;
    }
 
    std::shared_ptr<Nodes::Network::GpuFieldOperator> field_op;
    for (const auto& op : op_chain->operators()) {
        field_op = std::dynamic_pointer_cast<Nodes::Network::GpuFieldOperator>(op);
        if (field_op) {
            break;
        }
    }
    if (!field_op) {
        return;
    }
 
    auto self = std::dynamic_pointer_cast<NetworkGeometryBuffer>(shared_from_this());
    auto chain = get_processing_chain();
    if (!self || !chain) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "NetworkGeometryBuffer: no processing chain to wire field stages onto");
        return;
    }
 
    const DeferredFieldPass field_pass {
        .chain = field_op->binding_count() > 0 ? chain.get() : nullptr,
        .field_op = field_op,
        .buffer = self
    };
 
    const auto& pconfig = field_op->get_field_config();
    if (!pconfig.absorb_radius.has_value() && !pconfig.density_color) {
        return;
    }
 
    if (pconfig.transfer_on_claim && !pconfig.absorb_radius.has_value()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "NetworkGeometryBuffer: transfer_on_claim requires absorb_radius (there is no "
            "claim to reinterpret without it); transfer disabled");
    }
 
    auto* physics = dynamic_cast<Nodes::Network::PhysicsOperator*>(get_network()->get_operator());
 
    float cell_size = 0.0F;
    if (pconfig.cell_size.has_value()) {
        cell_size = *pconfig.cell_size;
    } else if (physics) {
        cell_size = physics->get_interaction_radius();
    } else {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "NetworkGeometryBuffer: SpatialFieldConfig has no cell_size and the network's "
            "primary operator is not a PhysicsOperator, so one cannot be derived");
        return;
    }
 
    auto hash_config = SpatialHashConfig::from_network(self, cell_size);
    if (!hash_config.has_value()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "NetworkGeometryBuffer: SpatialHashConfig::from_network failed");
        return;
    }
 
    const uint32_t live_count = hash_config->particle_count;
    bool reserve_enabled = pconfig.reserve_fraction > 0.0F;
 
    if (reserve_enabled && !pconfig.absorb_radius.has_value()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "NetworkGeometryBuffer: reserve_fraction requires absorb_radius (destroy-on-"
            "absorption has nothing to destroy without claims); reserve capacity disabled");
        reserve_enabled = false;
    }
 
    uint32_t total_count = live_count;
    if (reserve_enabled) {
        const auto reserve_count = static_cast<uint32_t>(
            std::ceil(static_cast<float>(live_count) * pconfig.reserve_fraction));
        total_count = live_count + reserve_count;
 
        const size_t needed_bytes = static_cast<size_t>(total_count) * hash_config->stride_words * 4;
        self->resize(needed_bytes, true);
 
        hash_config->particle_count = total_count;
    }
 
    if (total_count != live_count) {
        hash_config->declare_fields(self);
 
        std::vector<uint32_t> cluster_ids(total_count, 0U);
        if (auto* graphics_op
            = dynamic_cast<Nodes::Network::GraphicsOperator*>(get_network()->get_operator())) {
            auto live_ids = graphics_op->build_cluster_ids();
            std::copy_n(live_ids.begin(),
                std::min<size_t>(live_ids.size(), live_count), cluster_ids.begin());
        }
        std::shared_ptr<VKBuffer> cluster_staging;
        upload_back_buffer(self->write_state_slot("hash_cluster_id"), cluster_ids.data(),
            cluster_ids.size() * sizeof(uint32_t), cluster_staging);
    } else {
        self->ensure_cluster_ids();
        hash_config->declare_fields(self);
    }
 
    std::optional<PopulationConfig> pop_config;
    if (reserve_enabled) {
        pop_config = PopulationConfig { .hash = *hash_config, .live_count = live_count };
        pop_config->declare_fields(self);
        chain->add_processor(std::make_shared<PopulationInitProcessor>(*pop_config), self);
    }
 
    chain->add_processor(std::make_shared<HashClearProcessor>(*hash_config), self);
    chain->add_processor(std::make_shared<HashCountProcessor>(*hash_config, reserve_enabled), self);
    chain->add_processor(std::make_shared<HashScanProcessor>(*hash_config), self);
    chain->add_processor(std::make_shared<HashScatterProcessor>(*hash_config, reserve_enabled), self);
 
    if (pconfig.density_color) {
        chain->add_processor(
            std::make_shared<HashDensityColorProcessor>(*hash_config, field_op), self);
    }
 
    if (!pconfig.absorb_radius.has_value()) {
        return;
    }
 
    MutationConfig claim_config { .hash = *hash_config, .absorb_radius = *pconfig.absorb_radius };
    claim_config.declare_fields(self);
 
    const bool transfer_on_claim = pconfig.transfer_on_claim;
 
    chain->add_processor(std::make_shared<ClaimInitProcessor>(claim_config), self);
    chain->add_processor(
        std::make_shared<ClaimProcessor>(claim_config, field_op, reserve_enabled), self);
    chain->add_processor(std::make_shared<ClaimFlattenProcessor>(claim_config), self);
    chain->add_processor(
        std::make_shared<ClaimAccumulateProcessor>(
            claim_config, physics, reserve_enabled ? live_count : 0U, field_op, transfer_on_claim),
        self);
 
    if (pconfig.cosmetic_swallow) {
        chain->add_processor(
            std::make_shared<ClaimSwallowProcessor>(claim_config, field_op, transfer_on_claim), self);
    }
 
    if (transfer_on_claim) {
        chain->add_processor(std::make_shared<ClaimTransferProcessor>(claim_config), self);
    }
 
    if (pop_config.has_value()) {
        chain->add_processor(
            std::make_shared<PopulationSpawnProcessor>(*pop_config, field_op), self);
    }
}

References MayaFlux::Journal::Buffers, chain, MayaFlux::Buffers::SpatialHashConfig::declare_fields(), field_op, MayaFlux::Buffers::SpatialHashConfig::from_network(), MayaFlux::Nodes::Network::PhysicsOperator::get_interaction_radius(), get_network(), MayaFlux::Buffers::VKBuffer::get_processing_chain(), MayaFlux::Buffers::MutationConfig::hash, MayaFlux::Buffers::PopulationConfig::hash, MayaFlux::Journal::Init, m_network, MF_ERROR, and MayaFlux::Buffers::upload_back_buffer().

Referenced by setup_processors().

Here is the call graph for this function:

Here is the caller graph for this function: