set_gpu_executor()

void MayaFlux::Nodes::Network::MeshFieldOperator::set_gpu_executor	(	std::shared_ptr< Yantra::ShaderExecutionContext<> >	executor,
		bool	continuous = true
	)

Attach a GPU executor and switch to async dispatch mode.

Constructs a GpuComputeNode from the executor. On process() calls, compute_frame() is driven on the node instead of the per-slot CPU FieldOperator loop.

The on_complete callback expects gpu_result.primary to contain vertex data for each slot packed sequentially: slot 0 vertices, then slot 1 vertices, etc. Vertex count per slot must match the node's current get_mesh_vertex_count() at the time the callback fires. The callback writes back via slot.node->set_mesh_vertices().

Slot vertex counts are snapshotted at set_gpu_executor() time from the current m_slots state. Call set_gpu_executor() after slots are fully populated. If slot geometry changes after attachment, call set_gpu_executor() again to rebuild the snapshot.

CPU FieldOperator bindings are preserved but ignored while a GPU executor is attached. Passing nullptr clears the GPU path.

Parameters

executor	Pre-configured ShaderExecutionContext. nullptr clears.
continuous	If true the node re-arms after every completed dispatch.

Definition at line 117 of file MeshFieldOperator.cpp.

{
    if (!executor) {
        m_compute_node.reset();
        m_executor.reset();
        m_gpu_slot_vertex_counts.clear();
        return;
    }
 
    m_gpu_slot_vertex_counts.clear();
    if (m_slots) {
        m_gpu_slot_vertex_counts.reserve(m_slots->size());
        for (const auto& slot : *m_slots) {
            m_gpu_slot_vertex_counts.push_back(
                slot.node ? slot.node->get_mesh_vertex_count() : 0);
        }
    }
 
    m_executor = std::move(executor);
    m_compute_node = std::make_shared<Nodes::GpuSync::GpuComputeNode>(m_executor, continuous);
 
    m_compute_node->on_complete([this](Nodes::GpuSync::GpuComputeContext& ctx) {
        if (!m_slots)
            return;
 
        const auto& primary = ctx.gpu_result.primary;
        constexpr size_t floats_per_vertex = sizeof(MeshVertex) / sizeof(float);
 
        size_t offset = 0;
        for (size_t i = 0; i < m_slots->size(); ++i) {
            if (i >= m_gpu_slot_vertex_counts.size())
                break;
 
            const size_t vc = m_gpu_slot_vertex_counts[i];
            const size_t float_count = vc * floats_per_vertex;
 
            if (offset + float_count > primary.size())
                break;
 
            auto& slot = (*m_slots)[i];
            if (!slot.node) {
                offset += float_count;
                continue;
            }
 
            std::vector<MeshVertex> verts(vc);
            std::memcpy(verts.data(), primary.data() + offset,
                float_count * sizeof(float));
            slot.node->set_mesh_vertices(std::move(verts));
 
            offset += float_count;
        }
    });
 
    m_compute_node->set_dirty();
}

References MayaFlux::Nodes::GpuSync::GpuComputeContext::gpu_result, m_compute_node, m_executor, m_gpu_slot_vertex_counts, MayaFlux::Nodes::Network::MeshOperator::m_slots, and MayaFlux::Yantra::GpuChannelResult::primary.