Add Grass

CHANGELOG.md

@@ -11,6 +11,7 @@
 - Increase world size
 - Fix issue where chunks were only serialized on the client
 - Add feature flags for debug rendering
+- Add grass
 
 ## 0.1.1
 

Cargo.toml

@@ -61,4 +61,5 @@ ortho_camera = []
 lock_player = []
 physics_debug = []
 raycast_debug = []
+skip_terrain = []
 visual_debug = ["wireframe", "physics_debug", "raycast_debug"]

src/client/collider/systems.rs

@@ -1,3 +1,5 @@
+use terrain_util::client_block::block_properties;
+
 use crate::prelude::*;
 
 static COLLIDER_GRID_SIZE: u32 = 4;
@@ -56,7 +58,7 @@ pub fn handle_collider_update_events_system(
 
             match block {
                 Some(block) => {
-                    if block != BlockId::Air {
+                    if block_properties(block).has_collider {
                         transform.translation = collider_position + COLLIDER_CUBOID_WIDTH / 2.0;
                     } else {
                         transform.translation = COLLIDER_RESTING_POSITION;
@@ -133,7 +135,7 @@ mod tests {
             Vec3::new(1.0, 1.0, 1.0),
         );
         resource.insert_chunks(chunks);
-        resource.set_block(
+        resource.update_block(
             Vec3 {
                 x: 6.0,
                 y: 7.0,

src/client/player/systems/controller.rs

@@ -1,8 +1,12 @@
 use crate::prelude::*;
 
-#[cfg(not(feature = "lock_player"))]
+#[cfg(feature = "skip_terrain")]
+const SPAWN_POINT: Vec3 = Vec3::new(0.0, 1.0, 0.0);
+
+#[cfg(all(not(feature = "skip_terrain"), not(feature = "lock_player")))]
 const SPAWN_POINT: Vec3 = Vec3::new(0.0, 64.0, 0.0);
-#[cfg(feature = "lock_player")]
+
+#[cfg(all(not(feature = "skip_terrain"), feature = "lock_player"))]
 const SPAWN_POINT: Vec3 = Vec3::new(128.0, 96.0, -128.0);
 
 pub fn setup_player_camera(mut commands: Commands) {

src/client/player/systems/terrain.rs

@@ -8,7 +8,7 @@ pub fn handle_block_update_events(
     mut client: ResMut<RenetClient>,
 ) {
     for event in block_update_events.read() {
-        chunk_manager.set_block(event.position, event.block);
+        chunk_manager.update_block(event.position, event.block);
         info!("Block update message: {:?}", event.position);
 
         chunk_mesh_update_events.send(terrain_events::ChunkMeshUpdateEvent {

src/client/terrain/mod.rs

@@ -12,14 +12,30 @@ impl Plugin for TerrainPlugin {
     fn build(&self, app: &mut App) {
         info!("Building TerrainPlugin");
         app.insert_resource(ChunkManager::new());
-        app.insert_resource(terrain_resources::SpawnAreaLoaded(false));
         app.insert_resource(util::TextureManager::new());
+        app.insert_resource(resources::RenderMaterials::new());
         app.add_event::<terrain_events::BlockUpdateEvent>();
         app.add_event::<terrain_events::ChunkMeshUpdateEvent>();
         app.add_event::<terrain_events::WorldRegenerateEvent>();
-        app.add_systems(Startup, terrain_systems::prepare_spawn_area_system);
-        app.add_systems(Startup, terrain_systems::generate_world_system);
-        app.add_systems(Update, terrain_systems::handle_chunk_mesh_update_events);
-        app.add_systems(Update, terrain_systems::handle_terrain_regeneration_events);
+        app.add_systems(Startup, terrain_systems::prepare_mesher_materials_system);
+        #[cfg(feature = "skip_terrain")]
+        {
+            app.insert_resource(terrain_resources::SpawnAreaLoaded(true));
+            app.add_systems(Startup, terrain_systems::generate_simple_ground_system);
+        }
+        #[cfg(not(feature = "skip_terrain"))]
+        {
+            app.insert_resource(terrain_resources::SpawnAreaLoaded(false));
+            app.add_systems(Startup, terrain_systems::prepare_spawn_area_system);
+            app.add_systems(Startup, terrain_systems::generate_world_system);
+            app.add_systems(
+                Update,
+                terrain_systems::handle_chunk_mesh_update_events_system,
+            );
+            app.add_systems(
+                Update,
+                terrain_systems::handle_terrain_regeneration_events_system,
+            );
+        }
     }
 }

src/client/terrain/resources.rs

@@ -8,3 +8,24 @@ impl SpawnAreaLoaded {
         resource.0
     }
 }
+
+#[derive(Resource)]
+pub struct RenderMaterials {
+    pub transparent_material: Option<Handle<StandardMaterial>>,
+    pub chunk_material: Option<Handle<StandardMaterial>>,
+}
+
+impl Default for RenderMaterials {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl RenderMaterials {
+    pub fn new() -> RenderMaterials {
+        RenderMaterials {
+            transparent_material: None,
+            chunk_material: None,
+        }
+    }
+}

src/client/terrain/systems.rs

@@ -1,5 +1,36 @@
+use terrain_resources::RenderMaterials;
+use terrain_util::create_cross_mesh_for_chunk;
+
 use crate::prelude::*;
 
+pub fn prepare_mesher_materials_system(
+    mut render_materials: ResMut<RenderMaterials>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    asset_server: Res<AssetServer>,
+) {
+    let texture_handle = obtain_texture_handle(&asset_server);
+
+    let material = create_transparent_material(texture_handle.clone());
+    render_materials.transparent_material = Some(materials.add(material));
+
+    let material = create_chunk_material(texture_handle);
+    render_materials.chunk_material = Some(materials.add(material));
+}
+
+pub fn generate_simple_ground_system(
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut commands: Commands,
+) {
+    let mesh = Cuboid::new(64.0, 1.0, 64.0);
+
+    commands.spawn((
+        Mesh3d(meshes.add(mesh)),
+        MeshMaterial3d(materials.add(Color::srgba(1.0, 0.0, 1.0, 1.0))),
+        Name::new("Simple Ground Plane"),
+    ));
+}
+
 pub fn prepare_spawn_area_system(mut client: ResMut<RenetClient>) {
     info!("Sending chunk requests for spawn area");
 
@@ -38,16 +69,14 @@ pub fn generate_world_system(
     });
 }
 
-#[allow(clippy::too_many_arguments)]
-pub fn handle_chunk_mesh_update_events(
+pub fn handle_chunk_mesh_update_events_system(
     mut commands: Commands,
-    asset_server: Res<AssetServer>,
     mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
     chunk_manager: ResMut<ChunkManager>,
     mut chunk_mesh_update_events: EventReader<terrain_events::ChunkMeshUpdateEvent>,
     mut mesh_query: Query<(Entity, &terrain_components::ChunkMesh)>,
     texture_manager: ResMut<terrain_util::TextureManager>,
+    materials: Res<RenderMaterials>,
 ) {
     for event in chunk_mesh_update_events.read() {
         info!(
@@ -64,11 +93,17 @@ pub fn handle_chunk_mesh_update_events(
                 }
                 add_chunk_objects(
                     &mut commands,
-                    &asset_server,
                     &mut meshes,
-                    &mut materials,
                     chunk,
                     &texture_manager,
+                    &materials,
+                );
+                add_cross_objects(
+                    &mut commands,
+                    chunk,
+                    &materials,
+                    &texture_manager,
+                    &mut meshes,
                 );
             }
             None => {
@@ -80,90 +115,113 @@ pub fn handle_chunk_mesh_update_events(
 
 fn add_chunk_objects(
     commands: &mut Commands,
-    asset_server: &Res<AssetServer>,
     meshes: &mut ResMut<Assets<Mesh>>,
-    materials: &mut ResMut<Assets<StandardMaterial>>,
     chunk: &Chunk,
     texture_manager: &terrain_util::TextureManager,
+    materials: &RenderMaterials,
 ) {
-    if let Some(mesh) = create_chunk_mesh(chunk, texture_manager) {
-        let texture_handle = obtain_texture_handle(asset_server).clone();
-        let material = create_chunk_material(texture_handle, &mut ResMut::reborrow(materials));
-        spawn_chunk(
-            commands,
-            &mut ResMut::reborrow(meshes),
-            material,
-            mesh,
-            chunk,
-        );
+    if let Some(mesh) = terrain_util::create_chunk_mesh(chunk, texture_manager) {
+        let material = materials
+            .chunk_material
+            .clone()
+            .expect("Chunk material is loaded");
+
+        let meshes: &mut Mut<Assets<Mesh>> = &mut ResMut::reborrow(meshes);
+        commands.spawn((
+            Mesh3d(meshes.add(mesh)),
+            Transform::from_xyz(
+                chunk.position.x * CHUNK_SIZE as f32,
+                chunk.position.y * CHUNK_SIZE as f32,
+                chunk.position.z * CHUNK_SIZE as f32,
+            ),
+            MeshMaterial3d(material),
+            player_components::Raycastable,
+            terrain_components::ChunkMesh {
+                key: [
+                    chunk.position.x as i32,
+                    chunk.position.y as i32,
+                    chunk.position.z as i32,
+                ],
+            },
+            Name::from("Transparent Chunk Mesh"),
+        ));
     }
 }
 
-fn create_chunk_mesh(
+fn add_cross_objects(
+    commands: &mut Commands,
     chunk: &Chunk,
+    materials: &RenderMaterials,
     texture_manager: &terrain_util::TextureManager,
-) -> Option<Mesh> {
-    terrain_util::create_chunk_mesh(chunk, texture_manager)
+    meshes: &mut ResMut<Assets<Mesh>>,
+) {
+    if let Some(mesh) = create_cross_mesh_for_chunk(chunk, texture_manager) {
+        let mesh_handle = meshes.add(mesh);
+
+        commands.spawn((
+            Mesh3d(mesh_handle),
+            MeshMaterial3d(
+                materials
+                    .transparent_material
+                    .clone()
+                    .expect("Transparent material exists"),
+            ),
+            Transform::from_xyz(
+                chunk.position.x * CHUNK_SIZE as f32,
+                chunk.position.y * CHUNK_SIZE as f32,
+                chunk.position.z * CHUNK_SIZE as f32,
+            ),
+            terrain_components::ChunkMesh {
+                key: [
+                    chunk.position.x as i32,
+                    chunk.position.y as i32,
+                    chunk.position.z as i32,
+                ],
+            },
+        ));
+    }
+}
+
+fn create_transparent_material(texture_handle: Handle<Image>) -> StandardMaterial {
+    StandardMaterial {
+        perceptual_roughness: 1.0,
+        double_sided: true,
+        cull_mode: None,
+        reflectance: 0.0,
+        unlit: false,
+        specular_transmission: 0.0,
+        alpha_mode: AlphaMode::Mask(1.0),
+        base_color_texture: Some(texture_handle),
+        ..default()
+    }
 }
 
 #[cfg(not(feature = "wireframe"))]
-fn create_chunk_material(
-    texture_handle: Handle<Image>,
-    materials: &mut Mut<Assets<StandardMaterial>>,
-) -> Handle<StandardMaterial> {
-    materials.add(StandardMaterial {
+fn create_chunk_material(texture_handle: Handle<Image>) -> StandardMaterial {
+    StandardMaterial {
         perceptual_roughness: 0.5,
         reflectance: 0.0,
         unlit: false,
         specular_transmission: 0.0,
         base_color_texture: Some(texture_handle),
         ..default()
-    })
+    }
 }
 
 #[cfg(feature = "wireframe")]
-fn create_chunk_material(
-    _texture_handle: Handle<Image>,
-    materials: &mut Mut<Assets<StandardMaterial>>,
-) -> Handle<StandardMaterial> {
-    materials.add(StandardMaterial {
+fn create_chunk_material(_texture_handle: Handle<Image>) -> StandardMaterial {
+    StandardMaterial {
         base_color: Color::srgba(0.0, 0.0, 0.0, 0.0),
         alpha_mode: AlphaMode::Mask(0.5),
         ..default()
-    })
+    }
 }
 
 fn obtain_texture_handle(asset_server: &Res<AssetServer>) -> Handle<Image> {
     asset_server.load("textures/texture_atlas.png")
 }
 
-fn spawn_chunk(
-    commands: &mut Commands,
-    meshes: &mut Mut<Assets<Mesh>>,
-    material: Handle<StandardMaterial>,
-    mesh: Mesh,
-    chunk: &Chunk,
-) {
-    commands.spawn((
-        Mesh3d(meshes.add(mesh)),
-        Transform::from_xyz(
-            chunk.position.x * CHUNK_SIZE as f32,
-            chunk.position.y * CHUNK_SIZE as f32,
-            chunk.position.z * CHUNK_SIZE as f32,
-        ),
-        MeshMaterial3d(material),
-        player_components::Raycastable,
-        terrain_components::ChunkMesh {
-            key: [
-                chunk.position.x as i32,
-                chunk.position.y as i32,
-                chunk.position.z as i32,
-            ],
-        },
-    ));
-}
-
-pub fn handle_terrain_regeneration_events(
+pub fn handle_terrain_regeneration_events_system(
     mut client: ResMut<RenetClient>,
     mut world_regenerate_events: EventReader<terrain_events::WorldRegenerateEvent>,
     chunk_manager: ResMut<ChunkManager>,