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

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/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.