Add the initial framework for megastructures

To provide something to test with, an option has been added to scatter
a random assortment of horospheres throughout the world.

Author: patowen

client/src/sim.rs

@@ -88,6 +88,9 @@ impl Sim {
         local_character_id: EntityId,
     ) -> Self {
         let mut graph = Graph::new(cfg.chunk_size);
+        if cfg.horospheres_enabled {
+            graph.enable_horospheres();
+        }
         graph.ensure_node_state(NodeId::ROOT);
         Self {
             graph,

common/Cargo.toml

@@ -9,6 +9,7 @@ license = "Apache-2.0 OR Zlib"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+arrayvec = "0.7.6"
 blake3 = "1.3.3"
 serde = { version = "1.0.104", features = ["derive"] }
 nalgebra = { workspace = true, features = ["serde-serialize"] }

common/src/graph.rs

@@ -16,6 +16,7 @@ use crate::{
 pub struct Graph {
     nodes: FxHashMap<NodeId, NodeContainer>,
     layout: ChunkLayout,
+    horospheres_enabled: bool,
 }
 
 impl Graph {
@@ -25,9 +26,18 @@ impl Graph {
         Self {
             nodes,
             layout: ChunkLayout::new(dimension),
+            horospheres_enabled: false,
         }
     }
 
+    pub fn enable_horospheres(&mut self) {
+        self.horospheres_enabled = true;
+    }
+
+    pub fn horospheres_enabled(&self) -> bool {
+        self.horospheres_enabled
+    }
+
     #[inline]
     pub fn layout(&self) -> &ChunkLayout {
         &self.layout

common/src/lib.rs

@@ -25,6 +25,7 @@ pub mod lru_slab;
 mod margins;
 pub mod math;
 pub mod node;
+pub mod peer_traverser;
 mod plane;
 pub mod proto;
 mod sim_config;

common/src/node.rs

@@ -8,10 +8,11 @@ use crate::collision_math::Ray;
 use crate::dodeca::Vertex;
 use crate::graph::{Graph, NodeId};
 use crate::lru_slab::SlotId;
+use crate::peer_traverser::PeerTraverser;
 use crate::proto::{BlockUpdate, Position, SerializedVoxelData};
 use crate::voxel_math::{ChunkDirection, CoordAxis, CoordSign, Coords};
 use crate::world::Material;
-use crate::worldgen::NodeState;
+use crate::worldgen::{NodeState, PartialNodeState};
 use crate::{Chunks, margins};
 
 /// Unique identifier for a single chunk (1/20 of a dodecahedron) in the graph
@@ -28,21 +29,44 @@ impl ChunkId {
 }
 
 impl Graph {
+    /// Returns the PartialNodeState for the given node, panicking if it isn't initialized.
+    #[inline]
+    pub fn partial_node_state(&self, node_id: NodeId) -> &PartialNodeState {
+        self[node_id].partial_state.as_ref().unwrap()
+    }
+
+    /// Initializes the PartialNodeState for the given node if not already initialized,
+    /// initializing other nodes' NodeState and PartialNodeState as necessary
+    pub fn ensure_partial_node_state(&mut self, node_id: NodeId) {
+        if self[node_id].partial_state.is_some() {
+            return;
+        }
+
+        for (_, parent) in self.descenders(node_id) {
+            self.ensure_node_state(parent);
+        }
+
+        let partial_node_state = PartialNodeState::new(self, node_id);
+        self[node_id].partial_state = Some(partial_node_state);
+    }
+
     /// Returns the NodeState for the given node, panicking if it isn't initialized.
     #[inline]
     pub fn node_state(&self, node_id: NodeId) -> &NodeState {
         self[node_id].state.as_ref().unwrap()
     }
 
-    /// Initializes the NodeState for the given node and all its ancestors if not
-    /// already initialized.
+    /// Initializes the NodeState for the given node if not already initialized,
+    /// initializing other nodes' NodeState and PartialNodeState as necessary
     pub fn ensure_node_state(&mut self, node_id: NodeId) {
         if self[node_id].state.is_some() {
             return;
         }
 
-        for (_, parent) in self.descenders(node_id) {
-            self.ensure_node_state(parent);
+        self.ensure_partial_node_state(node_id);
+        let mut peers = PeerTraverser::new(node_id);
+        while let Some(peer) = peers.ensure_next(self) {
+            self.ensure_partial_node_state(peer.node());
         }
 
         let node_state = NodeState::new(self, node_id);
@@ -211,6 +235,7 @@ impl IndexMut<ChunkId> for Graph {
 /// used for rendering, is stored here.
 #[derive(Default)]
 pub struct Node {
+    pub partial_state: Option<PartialNodeState>,
     pub state: Option<NodeState>,
     /// We can only populate chunks which lie within a cube of populated nodes, so nodes on the edge
     /// of the graph always have some `Fresh` chunks.