Implement generator resource, add egui system boilerplate

Author: CuddlyBunion341

src/server/networking/systems.rs

@@ -8,6 +8,7 @@ pub fn receive_message_system(
     #[cfg(feature = "chat")] mut chat_message_events: EventWriter<
         chat_events::PlayerChatMessageSendEvent,
     >,
+    generator: Res<terrain_resources::Generator>,
 ) {
     for client_id in server.clients_id() {
         while let Some(message) = server.receive_message(client_id, DefaultChannel::ReliableOrdered)
@@ -56,9 +57,6 @@ pub fn receive_message_system(
                         client_id, player.position
                     );
                     player_states.players.insert(client_id, player);
-                }
-                NetworkingMessage::UpdateGeneratorParams(params) => {
-
                 }
                 NetworkingMessage::ChunkBatchRequest(positions) => {
                     info!(
@@ -75,11 +73,7 @@ pub fn receive_message_system(
                                 Some(chunk) => *chunk,
                                 None => {
                                     let mut chunk = Chunk::new(position);
-
-                                    let generator = terrain_util::generator::Generator::new(0);
-
                                     generator.generate_chunk(&mut chunk);
-
                                     chunk
                                 }
                             }

src/server/terrain/mod.rs

@@ -13,6 +13,9 @@ impl Plugin for TerrainPlugin {
         app.add_event::<terrain_events::BlockUpdateEvent>();
         app.insert_resource(resources::PastBlockUpdates::new());
         app.add_systems(Startup, terrain_systems::setup_world_system);
-        app.insert_resource(TerrainGeneratorParams::default());
+        app.insert_resource(resources::Generator::default());
+
+        // visualizer
+        app.add_systems(Update, terrain_systems::render_visualizer_system);
     }
 }

src/server/terrain/resources.rs

@@ -20,3 +20,44 @@ impl PastBlockUpdates {
         }
     }
 }
+
+#[derive(Resource)]
+pub struct Generator {
+    pub seed: u32,
+    pub perlin: Perlin, // TODO: reduce visibility of attributes on this struct decl
+    pub params: TerrainGeneratorParams,
+}
+
+impl Default for Generator {
+    fn default() -> Self {
+        Self::new(0)
+    }
+}
+
+pub struct TerrainGeneratorParams {
+    pub height_params: NoiseFunctionParams,
+    pub density_params: NoiseFunctionParams,
+}
+
+impl Default for TerrainGeneratorParams {
+    fn default() -> Self {
+        Self {
+            height_params: NoiseFunctionParams {
+                octaves: 4,
+                height: 0.0,
+                lacuranity: 2.0,
+                frequency: 1.0 / 60.0,
+                amplitude: 10.0,
+                persistence: 0.5,
+            },
+            density_params: NoiseFunctionParams {
+                octaves: 4,
+                height: 0.0,
+                lacuranity: 2.0,
+                frequency: 1.0 / 60.0,
+                amplitude: 10.0,
+                persistence: 0.5,
+            },
+        }
+    }
+}

src/server/terrain/systems.rs

@@ -1,20 +1,9 @@
-use bevy::ui::Node;
-use bevy_flair::style::components::NodeStyleSheet;
-
 use crate::prelude::*;
 
 pub fn setup_world_system(
     mut chunk_manager: ResMut<ChunkManager>,
-    params: Res<TerrainGeneratorParams>,
+    generator: Res<terrain_resources::Generator>,
 ) {
-    let generator = terrain_util::generator::Generator::new(
-        0,
-        TerrainGeneratorParams {
-            height_params: params.height_params,
-            density_params: params.density_params,
-        },
-    );
-
     let render_distance = Vec3::new(12.0, 2.0, 12.0);
 
     info!("Generating chunks");
@@ -29,23 +18,15 @@ pub fn setup_world_system(
     chunk_manager.insert_chunks(chunks);
 }
 
-// visualizer
+pub use visualizer::*;
 
-struct NoiseImageNode {}
+mod visualizer {
 
-pub fn setup_visualizer_system(
-    mut commands: Commands,
-    mut asset_server: ResMut<AssetServer>,
-) {
-    commands.spawn((
-            Node::default(),
-            Name::new("visualizer"),
-            NodeStyleSheet::new(asset_server.load("visualizer.css")),
-    )).with_children(|parent| {
-        parent.spawn((
-                Node::default(),
-                ImageNode::new(),
-                Name::new("noise_image"),
-        )
-    })
+    use bevy_inspector_egui::{bevy_egui::EguiContexts, egui};
+
+    pub fn render_visualizer_system(mut contexts: EguiContexts) {
+        egui::Window::new("Hello").show(contexts.ctx_mut(), |ui| {
+            ui.label("world");
+        });
+    }
 }

src/server/terrain/util/generator.rs

@@ -1,13 +1,13 @@
-use crate::prelude::*;
+use terrain_resources::{Generator, TerrainGeneratorParams};
 
-pub struct Generator {
-    pub seed: u32,
-    perlin: Perlin,
-    params: TerrainGeneratorParams,
-}
+use crate::prelude::*;
 
 impl Generator {
-    pub fn new(seed: u32, params: TerrainGeneratorParams) -> Generator {
+    pub fn new(seed: u32) -> Generator {
+        Self::new_with_params(seed, TerrainGeneratorParams::default())
+    }
+
+    pub fn new_with_params(seed: u32, params: TerrainGeneratorParams) -> Generator {
         Generator {
             seed,
             perlin: Perlin::new(seed),
@@ -41,14 +41,13 @@ impl Generator {
                 x: position.x,
                 y: position.z,
             },
-            default_params
+            default_params,
         );
 
         if (position.y as f64) < terrain_height + 20.0 {
             return BlockId::Stone;
         }
 
-
         // density -= position.y as f64 * 0.02;
         //
         // let base_block = BlockId::Stone;
@@ -67,7 +66,7 @@ impl Generator {
         //     BlockId::Air
         // }
 
-        BlockId::Air 
+        BlockId::Air
     }
 
     fn sample_3d(&self, position: Vec3, octaves: i32) -> f64 {
@@ -102,32 +101,29 @@ impl Generator {
             return sample;
         }
 
-        sample + self.sample_2d(position, &NoiseFunctionParams {
-            octaves: params.octaves - 1,
-            height: params.height + sample,
-            lacuranity: params.lacuranity,
-            frequency: params.frequency,
-            amplitude: params.amplitude * params.persistence,
-            persistence: params.persistence * 0.5,
-        })
+        sample
+            + self.sample_2d(
+                position,
+                &NoiseFunctionParams {
+                    octaves: params.octaves - 1,
+                    height: params.height + sample,
+                    lacuranity: params.lacuranity,
+                    frequency: params.frequency,
+                    amplitude: params.amplitude * params.persistence,
+                    persistence: params.persistence * 0.5,
+                },
+            )
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    #[test]
-    fn test_generator_new() {
-        let seed = 42;
-        let generator = Generator::new(seed);
-        assert_eq!(generator.seed, seed);
-    }
+    use terrain_resources::Generator;
 
     #[test]
     fn test_generate_chunk() {
-        let seed = 42;
-        let generator = Generator::new(seed);
+        let generator = Generator::default();
         let mut chunk = Chunk::new(Vec3::new(0.0, 0.0, 0.0));
 
         generator.generate_chunk(&mut chunk);
@@ -137,8 +133,7 @@ mod tests {
 
     #[test]
     fn test_sample_3d() {
-        let seed = 42;
-        let generator = Generator::new(seed);
+        let generator = Generator::default();
 
         let position = Vec3::new(0.0, 0.0, 0.0);
         let density = generator.sample_3d(position, 4);

src/server/terrain/util/mod.rs

@@ -2,4 +2,3 @@ pub mod blocks;
 pub mod generator;
 
 pub use blocks::*;
-pub use generator::*;

src/shared/networking.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use bevy::{math::{Quat, Vec3}, prelude::Resource};
+use bevy::math::{Quat, Vec3};
 use chrono::DateTime;
 use renet::{ChannelConfig, ClientId, ConnectionConfig, SendType};
 use serde::{Deserialize, Serialize};
@@ -50,36 +50,6 @@ pub enum NetworkingMessage {
     SingleChatMessageSync(ChatMessage),
     ChatMessageSync(Vec<ChatMessage>),
     BlockUpdate { position: Vec3, block: BlockId },
-    UpdateGeneratorParams(TerrainGeneratorParams),
-}
-
-#[derive(Serialize, Deserialize, Debug, Resource, Copy, Clone)]
-pub struct TerrainGeneratorParams {
-    pub height_params: NoiseFunctionParams,
-    pub density_params: NoiseFunctionParams,
-}
-
-impl Default for TerrainGeneratorParams {
-    fn default() -> Self {
-        Self {
-            height_params: NoiseFunctionParams {
-                octaves: 4,
-                height: 0.0,
-                lacuranity: 2.0,
-                frequency: 1.0 / 60.0,
-                amplitude: 10.0,
-                persistence: 0.5,
-            },
-            density_params: NoiseFunctionParams {
-                octaves: 4,
-                height: 0.0,
-                lacuranity: 2.0,
-                frequency: 1.0 / 60.0,
-                amplitude: 10.0,
-                persistence: 0.5,
-            },
-        }
-    }
 }
 
 #[derive(Serialize, Deserialize, Debug, Copy, Clone)]