Add Grass

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;

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/terrain/mod.rs

@@ -12,14 +12,25 @@ 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::Mesher::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::populate_mesher_meshes);
+        app.add_systems(Startup, terrain_systems::prepare_mesher_materials);
+        #[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);
+            app.add_systems(Update, terrain_systems::handle_terrain_regeneration_events);
+        }
     }
 }

src/client/terrain/resources.rs

@@ -1,3 +1,5 @@
+use terrain_util::client_block::MeshRepresentation;
+
 use crate::prelude::*;
 
 #[derive(Resource)]
@@ -8,3 +10,24 @@ impl SpawnAreaLoaded {
         resource.0
     }
 }
+
+#[derive(Resource)]
+pub struct Mesher {
+    pub mesh_handles: HashMap<MeshRepresentation, Handle<Mesh>>,
+    pub transparent_material_handle: Option<Handle<StandardMaterial>>,
+}
+
+impl Default for Mesher {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Mesher {
+    pub fn new() -> Mesher {
+        Mesher {
+            mesh_handles: HashMap::new(),
+            transparent_material_handle: None,
+        }
+    }
+}

src/client/terrain/systems.rs

@@ -1,5 +1,49 @@
+use terrain_resources::Mesher;
+use terrain_util::{
+    client_block::block_properties, get_cross_block_positions, instance_mesh_for_repr,
+};
+
 use crate::prelude::*;
 
+pub fn populate_mesher_meshes(
+    mut mesher: ResMut<Mesher>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    texture_manager: ResMut<terrain_util::TextureManager>,
+) {
+    BlockId::values().iter().for_each(|block_id| {
+        let mesh_repr = block_properties(*block_id).mesh_representation;
+        let mesh = instance_mesh_for_repr(mesh_repr.clone(), &texture_manager);
+        if let Some(mesh) = mesh {
+            let handle = meshes.add(mesh);
+            mesher.mesh_handles.insert(mesh_repr, handle);
+        }
+    });
+}
+
+pub fn prepare_mesher_materials(
+    mut mesher: ResMut<Mesher>,
+    materials: ResMut<Assets<StandardMaterial>>,
+    asset_server: Res<AssetServer>,
+) {
+    let texture_handle = obtain_texture_handle(&asset_server).clone();
+    let material_handle = create_transparent_material(texture_handle, materials);
+    mesher.transparent_material_handle = Some(material_handle);
+}
+
+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");
 
@@ -15,7 +59,7 @@ pub fn generate_world_system(
     mut client: ResMut<RenetClient>,
     mut chunk_manager: ResMut<ChunkManager>,
 ) {
-    let render_distance = Vec3::new(4.0, 4.0, 4.0);
+    let render_distance = Vec3::new(1.0, 1.0, 1.0);
 
     info!("Sending chunk requests for chunks");
 
@@ -48,6 +92,7 @@ pub fn handle_chunk_mesh_update_events(
     mut chunk_mesh_update_events: EventReader<terrain_events::ChunkMeshUpdateEvent>,
     mut mesh_query: Query<(Entity, &terrain_components::ChunkMesh)>,
     texture_manager: ResMut<terrain_util::TextureManager>,
+    mesher: Res<Mesher>,
 ) {
     for event in chunk_mesh_update_events.read() {
         info!(
@@ -70,6 +115,7 @@ pub fn handle_chunk_mesh_update_events(
                     chunk,
                     &texture_manager,
                 );
+                add_cross_objects(&mut commands, chunk, &mesher);
             }
             None => {
                 println!("No chunk found");
@@ -99,13 +145,56 @@ fn add_chunk_objects(
     }
 }
 
+fn add_cross_objects(commands: &mut Commands, chunk: &Chunk, mesher: &Mesher) {
+    let values = get_cross_block_positions(chunk);
+    for (mesh_repr, positions) in values {
+        let mesh_handle = mesher
+            .mesh_handles
+            .get(&mesh_repr)
+            .expect("Handle is not yet populated");
+        let material_handle = mesher
+            .transparent_material_handle
+            .clone()
+            .expect("Material has not yet been set");
+
+        for position in positions {
+            commands.spawn((
+                Mesh3d(mesh_handle.clone()),
+                MeshMaterial3d(material_handle.clone()),
+                Transform::from_xyz(
+                    chunk.position.x * CHUNK_SIZE as f32 + position.x,
+                    chunk.position.y * CHUNK_SIZE as f32 + position.y,
+                    chunk.position.z * CHUNK_SIZE as f32 + position.z,
+                ),
+            ));
+        }
+    }
+}
+
 fn create_chunk_mesh(
     chunk: &Chunk,
     texture_manager: &terrain_util::TextureManager,
 ) -> Option<Mesh> {
     terrain_util::create_chunk_mesh(chunk, texture_manager)
 }
 
+fn create_transparent_material(
+    texture_handle: Handle<Image>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) -> Handle<StandardMaterial> {
+    materials.add(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>,

src/client/terrain/util/blocks.rs

@@ -15,8 +15,76 @@ pub enum TextureName {
     OakLeaves,
     OakLogTop,
     OakLogSide,
+    Tallgrass,
 }
 
+pub mod client_block {
+    use super::TextureName;
+    use rsmc::BlockId;
+
+    #[derive(Eq, Hash, PartialEq, Clone)]
+    pub enum MeshRepresentation {
+        None,
+        Cube([TextureName; 6]),
+        Cross([TextureName; 2]),
+    }
+
+    use MeshRepresentation::*;
+
+    pub struct BlockProperties {
+        pub has_collider: bool,
+        pub mesh_representation: MeshRepresentation,
+    }
+
+    pub fn block_properties(block_id: BlockId) -> BlockProperties {
+        use TextureName::*;
+
+        let touple = match block_id {
+            BlockId::Air => (false, None),
+            BlockId::Grass => (
+                true,
+                Cube([GrassTop, Dirt, GrassSide, GrassSide, GrassSide, GrassSide]),
+            ),
+            BlockId::Dirt => (true, Cube([Dirt; 6])),
+            BlockId::Stone => (true, Cube([Stone; 6])),
+            BlockId::CobbleStone => (true, Cube([CobbleStone; 6])),
+            BlockId::Bedrock => (true, Cube([Bedrock; 6])),
+            BlockId::IronOre => (true, Cube([IronOre; 6])),
+            BlockId::CoalOre => (true, Cube([CoalOre; 6])),
+            BlockId::OakLeaves => (true, Cube([OakLeaves; 6])),
+            BlockId::OakLog => (
+                true,
+                Cube([
+                    OakLogTop, OakLogTop, OakLogSide, OakLogSide, OakLogSide, OakLogSide,
+                ]),
+            ),
+            BlockId::Tallgrass => (false, Cross([Tallgrass, Tallgrass])),
+        };
+
+        BlockProperties {
+            has_collider: touple.0,
+            mesh_representation: touple.1,
+        }
+    }
+
+    pub fn collect_all_texture_names() -> Vec<TextureName> {
+        BlockId::values()
+            .iter()
+            .flat_map(|block_id| {
+                let properties = block_properties(*block_id);
+                let mesh: MeshRepresentation = properties.mesh_representation;
+
+                match mesh {
+                    MeshRepresentation::None => vec![],
+                    MeshRepresentation::Cube(textures) => Vec::from(textures),
+                    MeshRepresentation::Cross(textures) => Vec::from(textures),
+                }
+            })
+            .collect()
+    }
+}
+
+use client_block::block_properties;
 use TextureName::*;
 
 #[derive(Resource)]
@@ -55,7 +123,7 @@ impl TextureManager {
             [Stone, CobbleStone, GrassTop, OakLeaves],
             [IronOre, Sand, GrassSide, OakLogTop],
             [CoalOre, Bedrock, Dirt, OakLogSide],
-            [Air, Air, Air, Air],
+            [Tallgrass, Air, Air, Air],
         ];
 
         let mut texture_positions = Vec::new();
@@ -83,51 +151,6 @@ pub struct Block {
     pub is_solid: bool,
 }
 
-macro_rules! add_block {
-    ($block_id:expr, $texture_names:expr, $is_solid:expr) => {
-        Block {
-            id: $block_id,
-            texture_names: $texture_names,
-            is_solid: $is_solid,
-        }
-    };
-}
-
-pub static BLOCKS: [Block; 10] = [
-    add_block!(BlockId::Air, [TextureName::Air; 6], false),
-    add_block!(
-        BlockId::Grass,
-        [
-            TextureName::GrassTop,
-            TextureName::Dirt,
-            TextureName::GrassSide,
-            TextureName::GrassSide,
-            TextureName::GrassSide,
-            TextureName::GrassSide,
-        ],
-        true
-    ),
-    add_block!(BlockId::Dirt, [TextureName::Dirt; 6], true),
-    add_block!(BlockId::Stone, [TextureName::Stone; 6], true),
-    add_block!(BlockId::CobbleStone, [TextureName::CobbleStone; 6], true),
-    add_block!(BlockId::Bedrock, [TextureName::Bedrock; 6], true),
-    add_block!(BlockId::IronOre, [TextureName::IronOre; 6], true),
-    add_block!(BlockId::CoalOre, [TextureName::CoalOre; 6], true),
-    add_block!(BlockId::OakLeaves, [TextureName::OakLeaves; 6], true),
-    add_block!(
-        BlockId::OakLog,
-        [
-            TextureName::OakLogTop,
-            TextureName::OakLogTop,
-            TextureName::OakLogSide,
-            TextureName::OakLogSide,
-            TextureName::OakLogSide,
-            TextureName::OakLogSide,
-        ],
-        true
-    ),
-];
-
 type TextureUV = [f32; 2];
 
 impl Block {
@@ -136,8 +159,18 @@ impl Block {
         face: CubeFace,
         texture_manager: &TextureManager,
     ) -> Option<[f32; 2]> {
-        let block = &BLOCKS[block_id as usize];
-        let texture_name = block.texture_names[face as usize];
-        texture_manager.get_texture_uv(texture_name).copied()
+        let properties = block_properties(block_id);
+        let mesh = properties.mesh_representation;
+
+        let texture_option: Option<TextureName> = match mesh {
+            client_block::MeshRepresentation::None => None,
+            client_block::MeshRepresentation::Cube(textures) => Some(textures[face as usize]),
+            client_block::MeshRepresentation::Cross(textures) => Some(textures[face as usize]),
+        };
+
+        match texture_option {
+            Some(texture_name) => texture_manager.get_texture_uv(texture_name).copied(),
+            None => None,
+        }
     }
 }