TopologyOperator.hpp

Go to the documentation of this file.

#pragma once
#include "GraphicsOperator.hpp"
#include "MayaFlux/Nodes/Graphics/TopologyGeneratorNode.hpp"
 
namespace MayaFlux::Nodes::Network {
 
class MAYAFLUX_API TopologyOperator : public GraphicsOperator {
public:
    explicit TopologyOperator(
        Kinesis::ProximityMode mode = Kinesis::ProximityMode::K_NEAREST);
 
    ~TopologyOperator() override { m_shutdown.store(true, std::memory_order_release); }
 
    /**
     * @brief Initialize a single topology with single set of vertices
     */
    void initialize(const std::vector<LineVertex>& vertices);
 
    /**
     * @brief Initialize multiple topologies with given positions and properties.
     * @param topologies Vector of position vectors, one per topology.
     * @param mode Proximity mode for all topologies.
     */
    void initialize_topologies(
        const std::vector<std::vector<LineVertex>>& topologies,
        Kinesis::ProximityMode mode);
 
    /**
     * @brief Add a single topology with full per-vertex control.
     * @param vertices Vector of LineVertex defining the topology's points and attributes.
     * @param mode Proximity mode for this topology.
     */
    void add_topology(
        const std::vector<LineVertex>& vertices,
        Kinesis::ProximityMode mode);
 
    void process(float dt) override;
 
    [[nodiscard]] std::span<const uint8_t> get_vertex_data() const override;
    [[nodiscard]] std::span<const uint8_t> get_vertex_data_for_collection(uint32_t idx) const override;
    [[nodiscard]] Kakshya::VertexLayout get_vertex_layout() const override;
    [[nodiscard]] size_t get_vertex_count() const override;
    [[nodiscard]] bool is_vertex_data_dirty() const override;
    void mark_vertex_data_clean() override;
 
    /**
     * @brief One DirtyVertexRange per topology whose TopologyGeneratorNode
     *        needs a GPU update, so add_topology() or a point edit on one
     *        graph re-uploads only that graph's expanded line vertices.
     *
     * Ranges are in add_topology() order, matching get_vertex_data() and
     * build_cluster_ids(); group_index is the topology index and feeds
     * get_vertex_data_for_collection(). Empty when no topology changed. A
     * point edit within one graph still re-uploads that whole graph's range,
     * since its connectivity rebuild is global; isolation here is across
     * graphs, not within one.
     */
    [[nodiscard]] std::vector<DirtyVertexRange> dirty_vertex_ranges() const override;
 
    /**
     * @brief True: point edits, add_topology() and every proximity-parameter
     *        change route through a TopologyGeneratorNode dirty flag, so
     *        per-graph ranges are complete. Isolation is across graphs only;
     *        a change inside one graph re-uploads that graph's whole range.
     */
    [[nodiscard]] bool supports_incremental_upload() const override { return true; }
 
    /**
     * @brief Extract current vertex data as LineVertex array
     * @return Vector of LineVertex with current positions, colors, thicknesses
     */
    [[nodiscard]] std::vector<LineVertex> extract_vertices() const;
 
    void set_parameter(std::string_view param, double value) override;
    [[nodiscard]] std::optional<double> query_state(std::string_view query) const override;
    [[nodiscard]] std::string_view get_type_name() const override { return "Topology"; }
    [[nodiscard]] size_t get_point_count() const override;
 
    /**
     * @brief Overrides GraphicsOperator::build_cluster_ids() for real
     *        multi-topology scenes.
     * @return get_vertex_count() elements: entry i is the index of the
     *         topology (in initialize_topologies()/add_topology() order)
     *         vertex i belongs to, in the same concatenation order
     *         get_vertex_data() itself produces. All zero when there is at
     *         most one topology, matching the base class default exactly.
     *
     * A single TopologyOperator holding several independent topologies
     * (initialize_topologies/add_topology, each its own connected MST/KNN
     * graph) is the same "many complete vertex-array packs" shape
     * PhysicsOperator's collections are. Overriding this is what lets a
     * cluster-scoped GpuFieldOperator binding, or the spatial hash's own
     * cluster guard, treat each topology as its own population without a
     * dynamic_cast anywhere in the buffer layer.
     */
    [[nodiscard]] std::vector<uint32_t> build_cluster_ids() const override;
 
    /**
     * @brief Access a specific topology node directly.
     * @param i Collection index.
     * @return Shared pointer to the TopologyGeneratorNode, or nullptr if out of range.
     */
    [[nodiscard]] std::shared_ptr<GpuSync::TopologyGeneratorNode> get_topology(size_t i) const
    {
        if (i >= m_topologies.size()) {
            return nullptr;
        }
        return m_topologies[i];
    }
 
    /**
     * @brief Set the connection radius for topology generation.
     * @param radius Connection radius.
     */
    void set_connection_radius(float radius);
 
    /**
     * @brief Set the number of neighbors (k) for K-Nearest topology mode.
     * @param k Number of neighbors.
     */
    void set_global_line_thickness(float thickness);
 
    /**
     * @brief Set the line color for all topologies.
     * @param color RGB color.
     */
    void set_global_line_color(const glm::vec3& color);
 
    /**
     * @brief Set number of samples per segment for interpolation for all topologies.
     * @param samples Number of samples to generate per connection segment
     *
     * Higher values produce smoother curves but increase vertex count.
     */
    void set_samples_per_segment(size_t samples);
 
    /**
     * @brief Get number of topologies currently stored
     * @return Topology count
     */
    [[nodiscard]] size_t get_topology_count() const { return m_topologies.size(); }
 
    const char* get_vertex_type_name() const override { return "PathVertex"; }
 
protected:
    void* get_data_at(size_t global_index) override;
 
private:
    std::vector<std::shared_ptr<GpuSync::TopologyGeneratorNode>> m_topologies;
 
    mutable std::vector<uint8_t> m_vertex_data_aggregate;
 
    Kinesis::ProximityMode m_default_mode;
    float m_default_thickness { 2.0F };
 
    mutable std::atomic<uint32_t> m_access_token { 0 };
    std::atomic<bool> m_shutdown { false };
};
 
} // namespace MayaFlux::Nodes::Network