Refactor texture definitions (#6)

* Refactor texture definitions

* Introduce texture_manager

* Add texture manager resource to terrain plugin, fix visibility

* Fix clippy

* Fix linter

* Attempt fix clippy

* Fix linter fr fr

Author: CuddlyBunion341

src/client/terrain/mod.rs

@@ -11,6 +11,7 @@ pub struct TerrainPlugin;
 impl Plugin for TerrainPlugin {
     fn build(&self, app: &mut App) {
         app.insert_resource(terrain_resources::ChunkManager::new());
+        app.insert_resource(util::TextureManager::new());
         app.add_event::<terrain_events::BlockUpdateEvent>();
         app.add_event::<terrain_events::ChunkMeshUpdateEvent>();
         app.add_systems(Startup, terrain_systems::setup_world_system);

src/client/terrain/systems.rs

@@ -6,6 +6,7 @@ pub fn setup_world_system(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut chunk_manager: ResMut<terrain_resources::ChunkManager>,
+    texture_manager: ResMut<terrain_util::TextureManager>,
 ) {
     let generator = terrain_util::generator::Generator::new(0);
 
@@ -24,12 +25,14 @@ pub fn setup_world_system(
             &mut meshes,
             &mut materials,
             chunk,
+            &texture_manager,
         );
     }
 
     chunk_manager.insert_chunks(chunks);
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn handle_chunk_mesh_update_events(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
@@ -38,6 +41,7 @@ pub fn handle_chunk_mesh_update_events(
     mut chunk_manager: ResMut<terrain_resources::ChunkManager>,
     mut chunk_mesh_update_events: EventReader<terrain_events::ChunkMeshUpdateEvent>,
     mut mesh_query: Query<(Entity, &terrain_components::ChunkMesh)>,
+    texture_manager: ResMut<terrain_util::TextureManager>,
 ) {
     for event in chunk_mesh_update_events.read() {
         let chunk_option = chunk_manager.get_chunk(event.position);
@@ -54,6 +58,7 @@ pub fn handle_chunk_mesh_update_events(
                     &mut meshes,
                     &mut materials,
                     chunk,
+                    &texture_manager,
                 );
             }
             None => {
@@ -69,9 +74,10 @@ fn add_chunk_objects(
     meshes: &mut ResMut<Assets<Mesh>>,
     materials: &mut ResMut<Assets<StandardMaterial>>,
     chunk: &terrain_util::Chunk,
+    texture_manager: &terrain_util::TextureManager,
 ) {
     let texture_handle: Handle<Image> = asset_server.load("textures/texture_atlas.png");
-    let mesh_option = terrain_util::create_chunk_mesh(chunk);
+    let mesh_option = terrain_util::create_chunk_mesh(chunk, texture_manager);
 
     if mesh_option.is_none() {
         return;

src/client/terrain/util/blocks.rs

@@ -1,8 +1,64 @@
 use crate::prelude::*;
 
+#[derive(Hash, Eq, PartialEq, Copy, Clone)]
+pub enum TextureName {
+    Air,
+    Stone,
+    Dirt,
+    GrassTop,
+    GrassSide,
+    Bedrock,
+    RedSand,
+    BrownTerracotta,
+    CyanTerracotta,
+    GrayTerracotta,
+    LightGrayTerracotta,
+    OrangeTerracotta,
+    RedTerracotta,
+    Terracotta,
+    YellowTerracotta,
+}
+
+#[derive(Resource)]
+pub struct TextureManager {
+    textures: HashMap<TextureName, TextureUV>,
+}
+
+impl Default for TextureManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TextureManager {
+    pub fn new() -> Self {
+        let mut textures = HashMap::new();
+        textures.insert(TextureName::Air, [-1.0, -1.0]);
+        textures.insert(TextureName::Stone, [0.0, 0.0]);
+        textures.insert(TextureName::Dirt, [0.25, 0.0]);
+        textures.insert(TextureName::GrassTop, [0.5, 0.0]);
+        textures.insert(TextureName::GrassSide, [0.75, 0.0]);
+        textures.insert(TextureName::Bedrock, [0.0, 0.25]);
+        textures.insert(TextureName::RedSand, [0.25, 0.25]);
+        textures.insert(TextureName::BrownTerracotta, [0.5, 0.25]);
+        textures.insert(TextureName::CyanTerracotta, [0.75, 0.25]);
+        textures.insert(TextureName::GrayTerracotta, [0.0, 0.5]);
+        textures.insert(TextureName::LightGrayTerracotta, [0.25, 0.5]);
+        textures.insert(TextureName::OrangeTerracotta, [0.5, 0.5]);
+        textures.insert(TextureName::RedTerracotta, [0.75, 0.5]);
+        textures.insert(TextureName::Terracotta, [0.0, 0.75]);
+        textures.insert(TextureName::YellowTerracotta, [0.25, 0.75]);
+        Self { textures }
+    }
+
+    pub fn get_texture_uv(&self, name: TextureName) -> Option<&TextureUV> {
+        self.textures.get(&name)
+    }
+}
+
 pub struct Block {
     pub id: BlockId,
-    pub texture_names: [&'static str; 6],
+    pub texture_names: [TextureName; 6],
     pub is_solid: bool,
 }
 
@@ -17,61 +73,71 @@ macro_rules! add_block {
 }
 
 pub static BLOCKS: [Block; 14] = [
-    add_block!(BlockId::Air, ["air"; 6], false),
+    add_block!(BlockId::Air, [TextureName::Air; 6], false),
     add_block!(
         BlockId::Grass,
         [
-            "grass_top",
-            "dirt",
-            "grass_side",
-            "grass_side",
-            "grass_side",
-            "grass_side",
+            TextureName::GrassTop,
+            TextureName::Dirt,
+            TextureName::GrassSide,
+            TextureName::GrassSide,
+            TextureName::GrassSide,
+            TextureName::GrassSide,
         ],
         true
     ),
-    add_block!(BlockId::Dirt, ["dirt"; 6], true),
-    add_block!(BlockId::Stone, ["stone"; 6], true),
-    add_block!(BlockId::Bedrock, ["bedrock"; 6], true),
-    add_block!(BlockId::RedSand, ["red_sand"; 6], true),
-    add_block!(BlockId::BrownTerracotta, ["brown_terracotta"; 6], true),
-    add_block!(BlockId::CyanTerracotta, ["cyan_terracotta"; 6], true),
-    add_block!(BlockId::GrayTerracotta, ["gray_terracotta"; 6], true),
+    add_block!(BlockId::Dirt, [TextureName::Dirt; 6], true),
+    add_block!(BlockId::Stone, [TextureName::Stone; 6], true),
+    add_block!(BlockId::Bedrock, [TextureName::Bedrock; 6], true),
+    add_block!(BlockId::RedSand, [TextureName::RedSand; 6], true),
+    add_block!(
+        BlockId::BrownTerracotta,
+        [TextureName::BrownTerracotta; 6],
+        true
+    ),
+    add_block!(
+        BlockId::CyanTerracotta,
+        [TextureName::CyanTerracotta; 6],
+        true
+    ),
+    add_block!(
+        BlockId::GrayTerracotta,
+        [TextureName::GrayTerracotta; 6],
+        true
+    ),
     add_block!(
         BlockId::LightGrayTerracotta,
-        ["light_gray_terracotta"; 6],
+        [TextureName::LightGrayTerracotta; 6],
+        true
+    ),
+    add_block!(
+        BlockId::OrangeTerracotta,
+        [TextureName::OrangeTerracotta; 6],
+        true
+    ),
+    add_block!(
+        BlockId::RedTerracotta,
+        [TextureName::RedTerracotta; 6],
+        true
+    ),
+    add_block!(BlockId::Terracotta, [TextureName::Terracotta; 6], true),
+    add_block!(
+        BlockId::YellowTerracotta,
+        [TextureName::YellowTerracotta; 6],
         true
     ),
-    add_block!(BlockId::OrangeTerracotta, ["orange_terracotta"; 6], true),
-    add_block!(BlockId::RedTerracotta, ["red_terracotta"; 6], true),
-    add_block!(BlockId::Terracotta, ["terracotta"; 6], true),
-    add_block!(BlockId::YellowTerracotta, ["yellow_terracotta"; 6], true),
 ];
 
-impl Block {
-    pub fn get_texture_uvs(texture_name: &str) -> Option<[f32; 2]> {
-        match texture_name {
-            "stone" => Some([0.0, 0.0]),
-            "dirt" => Some([0.25, 0.0]),
-            "grass_top" => Some([0.5, 0.0]),
-            "grass_side" => Some([0.75, 0.0]),
-            "bedrock" => Some([0.0, 0.25]),
-            "red_sand" => Some([0.25, 0.25]),
-            "brown_terracotta" => Some([0.5, 0.25]),
-            "cyan_terracotta" => Some([0.75, 0.25]),
-            "gray_terracotta" => Some([0.0, 0.5]),
-            "light_gray_terracotta" => Some([0.25, 0.5]),
-            "orange_terracotta" => Some([0.5, 0.5]),
-            "red_terracotta" => Some([0.75, 0.5]),
-            "terracotta" => Some([0.0, 0.75]),
-            "yellow_terracotta" => Some([0.25, 0.75]),
-            _ => None,
-        }
-    }
+type TextureUV = [f32; 2];
 
-    pub fn get_block_face_uvs(block_id: BlockId, face: CubeFace) -> Option<[f32; 2]> {
+impl Block {
+    pub fn get_block_face_uvs(
+        block_id: BlockId,
+        face: CubeFace,
+        texture_manager: &TextureManager,
+    ) -> Option<[f32; 2]> {
         let block = &BLOCKS[block_id as usize];
         let texture_name = block.texture_names[face as usize];
-        Self::get_texture_uvs(texture_name)
+        texture_manager.get_texture_uv(texture_name).copied()
     }
 }

src/client/terrain/util/mesher.rs

@@ -1,3 +1,5 @@
+use terrain_util::TextureManager;
+
 use crate::prelude::*;
 
 pub fn create_cube_mesh_from_data(geometry_data: GeometryData) -> Option<Mesh> {
@@ -32,6 +34,7 @@ pub fn create_cube_geometry_data(
     z: f32,
     faces: u8,
     block_id: BlockId,
+    texture_manager: &TextureManager,
 ) -> GeometryData {
     let mut position = Vec::new();
     let mut uv = Vec::new();
@@ -52,7 +55,7 @@ pub fn create_cube_geometry_data(
                 vertex.position[2] * 0.5 + z + 0.5,
             ]);
 
-            let block_uvs = Block::get_block_face_uvs(block_id, *face).unwrap();
+            let block_uvs = Block::get_block_face_uvs(block_id, *face, texture_manager).unwrap();
             uv.push([
                 block_uvs[0] + vertex.uv[0] * 0.25 - 0.001,
                 block_uvs[1] + (1.0 - vertex.uv[1]) * 0.25,
@@ -75,7 +78,7 @@ pub fn create_cube_geometry_data(
     }
 }
 
-pub fn create_chunk_mesh(chunk: &Chunk) -> Option<Mesh> {
+pub fn create_chunk_mesh(chunk: &Chunk, texture_manager: &TextureManager) -> Option<Mesh> {
     let mut geometry_data = GeometryData {
         position: Vec::new(),
         uv: Vec::new(),
@@ -109,8 +112,14 @@ pub fn create_chunk_mesh(chunk: &Chunk) -> Option<Mesh> {
                 update_mask(chunk, &mut mask, 0b010000, x, y, z - 1);
                 update_mask(chunk, &mut mask, 0b100000, x, y, z + 1);
 
-                let cube_data =
-                    create_cube_geometry_data(x as f32, y as f32, z as f32, mask, block_id);
+                let cube_data = create_cube_geometry_data(
+                    x as f32,
+                    y as f32,
+                    z as f32,
+                    mask,
+                    block_id,
+                    texture_manager,
+                );
 
                 geometry_data.indices.extend(
                     cube_data