feat(ecs): add integration with vizoxide crateHEADmaster

2 files changed, 182 insertions, 0 deletions

diff --git a/ecs/src/component/storage.rs b/ecs/src/component/storage.rs
index 4b2b6d8..c70e7e7 100644
--- a/ecs/src/component/storage.rs
+++ b/ecs/src/component/storage.rs
@@ -421,6 +421,176 @@ impl TypeName for Storage
     }
 }
 
+#[cfg(feature = "vizoxide")]
+impl Storage
+{
+    pub fn create_vizoxide_archetype_graph(
+        &self,
+        graph_name: impl AsRef<str>,
+        params: VizoxideArchetypeGraphParams,
+    ) -> Result<vizoxide::Graph, vizoxide::GraphvizError>
+    {
+        let viz_graph = vizoxide::Graph::builder(graph_name.as_ref())
+            .strict(true)
+            .directed(true)
+            .build()?;
+
+        let mut viz_node_lookup = HashMap::new();
+
+        for node in self.graph.iter_nodes() {
+            let id = node.archetype().id();
+
+            if !viz_node_lookup.contains_key(&id) {
+                let node = self.graph.get_node_by_id(id).unwrap();
+
+                let viz_node = (params.create_node_cb)(
+                    node.archetype(),
+                    ArchetypeMetadata { is_imaginary: false },
+                    viz_graph.create_node(&(params.create_node_name)(
+                        node.archetype(),
+                        ArchetypeMetadata { is_imaginary: false },
+                    )),
+                )
+                .build()?;
+
+                viz_node_lookup.insert(id, viz_node);
+            }
+
+            for (edge_comp_id, edges) in node.iter_edges() {
+                if let Some(add_edge) = edges.add {
+                    if !viz_node_lookup.contains_key(&add_edge) {
+                        let viz_node = self.create_vizoxide_archetype_graph_edge_node(
+                            &viz_graph,
+                            node,
+                            add_edge,
+                            *edge_comp_id,
+                            &params,
+                        )?;
+
+                        viz_node_lookup.insert(add_edge, viz_node);
+                    }
+
+                    (params.create_edge_cb)(
+                        node.archetype(),
+                        *edge_comp_id,
+                        VizoxideArchetypeGraphEdgeKind::Add,
+                        viz_graph.create_edge(
+                            viz_node_lookup.get(&id).unwrap(),
+                            viz_node_lookup.get(&add_edge).unwrap(),
+                            Some(&format!("Add {}", edge_comp_id.id())),
+                        ),
+                    )
+                    .build()?;
+                }
+
+                if let Some(remove_edge) = edges.remove {
+                    if !viz_node_lookup.contains_key(&remove_edge) {
+                        let viz_node = self.create_vizoxide_archetype_graph_edge_node(
+                            &viz_graph,
+                            node,
+                            remove_edge,
+                            *edge_comp_id,
+                            &params,
+                        )?;
+
+                        viz_node_lookup.insert(remove_edge, viz_node);
+                    }
+
+                    (params.create_edge_cb)(
+                        node.archetype(),
+                        *edge_comp_id,
+                        VizoxideArchetypeGraphEdgeKind::Remove,
+                        viz_graph.create_edge(
+                            viz_node_lookup.get(&id).unwrap(),
+                            viz_node_lookup.get(&remove_edge).unwrap(),
+                            Some(&format!("Remove {}", edge_comp_id.id())),
+                        ),
+                    )
+                    .build()?;
+                }
+            }
+        }
+
+        drop(viz_node_lookup);
+
+        Ok(viz_graph)
+    }
+
+    fn create_vizoxide_archetype_graph_edge_node<'vizoxide_graph>(
+        &self,
+        viz_graph: &'vizoxide_graph vizoxide::Graph,
+        node: &graph::ArchetypeNode,
+        edge_id: ArchetypeId,
+        edge_comp_id: Uid,
+        params: &VizoxideArchetypeGraphParams,
+    ) -> Result<vizoxide::Node<'vizoxide_graph>, vizoxide::GraphvizError>
+    {
+        match self.graph.get_node_by_id(edge_id) {
+            Some(edge_node) => (params.create_node_cb)(
+                edge_node.archetype(),
+                ArchetypeMetadata { is_imaginary: false },
+                viz_graph.create_node(&(params.create_node_name)(
+                    edge_node.archetype(),
+                    ArchetypeMetadata { is_imaginary: false },
+                )),
+            )
+            .build(),
+            None => {
+                let mut comp_ids =
+                    node.archetype().component_ids_sorted().collect::<Vec<_>>();
+
+                let insert_index = comp_ids.partition_point(|cid| *cid <= edge_comp_id);
+
+                comp_ids.insert(insert_index, edge_comp_id);
+
+                let imaginary_edge_archetype = Archetype::new(edge_id, comp_ids);
+
+                (params.create_node_cb)(
+                    &imaginary_edge_archetype,
+                    ArchetypeMetadata { is_imaginary: true },
+                    viz_graph.create_node(&(params.create_node_name)(
+                        &imaginary_edge_archetype,
+                        ArchetypeMetadata { is_imaginary: true },
+                    )),
+                )
+                .build()
+            }
+        }
+    }
+}
+
+#[cfg(feature = "vizoxide")]
+pub struct VizoxideArchetypeGraphParams
+{
+    pub create_node_name: fn(&Archetype, ArchetypeMetadata) -> std::borrow::Cow<'_, str>,
+    pub create_node_cb: for<'storage, 'graph> fn(
+        &'storage Archetype,
+        ArchetypeMetadata,
+        vizoxide::NodeBuilder<'graph>,
+    ) -> vizoxide::NodeBuilder<'graph>,
+    pub create_edge_cb: for<'storage, 'graph> fn(
+        &'storage Archetype,
+        Uid,
+        VizoxideArchetypeGraphEdgeKind,
+        vizoxide::EdgeBuilder<'graph>,
+    ) -> vizoxide::EdgeBuilder<'graph>,
+}
+
+#[cfg(feature = "vizoxide")]
+#[derive(Debug, Clone)]
+pub struct ArchetypeMetadata
+{
+    pub is_imaginary: bool,
+}
+
+#[cfg(feature = "vizoxide")]
+#[derive(Debug, Clone, Copy)]
+pub enum VizoxideArchetypeGraphEdgeKind
+{
+    Add,
+    Remove,
+}
+
 #[derive(Debug)]
 pub struct ArchetypeRefIter<'storage, 'search_terms>
 {
diff --git a/ecs/src/component/storage/graph.rs b/ecs/src/component/storage/graph.rs
index a221877..11160e7 100644
--- a/ecs/src/component/storage/graph.rs
+++ b/ecs/src/component/storage/graph.rs
@@ -71,6 +71,12 @@ impl Graph
         }))
     }
 
+    #[cfg(feature = "vizoxide")]
+    pub fn iter_nodes(&self) -> impl Iterator<Item = &ArchetypeNode>
+    {
+        self.nodes.iter()
+    }
+
     pub fn dfs_archetype_add_edges(
         &self,
         archetype_id: ArchetypeId,
@@ -233,6 +239,12 @@ impl ArchetypeNode
         self.edges.entry(component_id).or_insert_with(insert_fn)
     }
 
+    #[cfg(feature = "vizoxide")]
+    pub fn iter_edges(&self) -> impl Iterator<Item = (&Uid, &ArchetypeEdges)>
+    {
+        self.edges.iter()
+    }
+
     pub fn get_edges_mut(&mut self, component_id: Uid) -> Option<&mut ArchetypeEdges>
     {
         debug_assert_eq!(component_id.kind(), UidKind::Component);