Add item rendering

Author: Technici4n

assets/shaders/model.frag

@@ -10,5 +10,10 @@ const vec3 SUN_DIRECTION = normalize(vec3(0, 1, 0.5));
 const float SUN_FRACTION = 0.3;
 
 void main() {
-    ColorBuffer = occl * vec4(v_Rgb, 1.0) * (1.0 - SUN_FRACTION + SUN_FRACTION * abs(dot(v_Norm, SUN_DIRECTION)));
+    /* VARIOUS BRIGHTNESS FACTORS */
+    float normal_factor = 1.0 - SUN_FRACTION + SUN_FRACTION * min(0.0, dot(v_Norm, SUN_DIRECTION));
+    float total_factor = occl * normal_factor;
+
+    /* OUTPUT */
+    ColorBuffer = vec4(v_Rgb * total_factor, 1.0);
 }

assets/shaders/model.vert

@@ -12,35 +12,21 @@ layout(location = 2) out vec3 v_Rgb;
 
 
 vec3 get_normal(uint id) {
-    if(id == 0u) {
+    if (id == 0u) {
         return vec3(1.0, 0.0, 0.0);
-    } else if(id == 1u) {
+    } else if (id == 1u) {
         return vec3(-1.0, 0.0, 0.0);
-    } else if(id == 2u) {
+    } else if (id == 2u) {
         return vec3(0.0, 1.0, 0.0);
-    } else if(id == 3u) {
+    } else if (id == 3u) {
         return vec3(0.0, -1.0, 0.0);
-    } else if(id == 4u) {
+    } else if (id == 4u) {
         return vec3(0.0, 0.0, 1.0);
     } else {
         return vec3(0.0, 0.0, -1.0);
     }
 }
 
-vec3 srgbEncode(vec3 color){
-    float r = color.r < 0.0031308 ? 12.92 * color.r : 1.055 * pow(color.r, 1.0/2.4) - 0.055;
-    float g = color.g < 0.0031308 ? 12.92 * color.g : 1.055 * pow(color.g, 1.0/2.4) - 0.055;
-    float b = color.b < 0.0031308 ? 12.92 * color.b : 1.055 * pow(color.b, 1.0/2.4) - 0.055;
-    return vec3(r, g, b);
-}
-
-vec3 srgbDecode(vec3 color){
-    float r = color.r < 0.04045 ? (1.0 / 12.92) * color.r : pow((color.r + 0.055) * (1.0 / 1.055), 2.4);
-    float g = color.g < 0.04045 ? (1.0 / 12.92) * color.g : pow((color.g + 0.055) * (1.0 / 1.055), 2.4);
-    float b = color.b < 0.04045 ? (1.0 / 12.92) * color.b : pow((color.b + 0.055) * (1.0 / 1.055), 2.4);
-    return vec3(r, g, b);
-}
-
 void main() {
     gl_Position = u_ViewProj * u_Model * vec4(a_Pos, 1.0);
 
@@ -67,6 +53,6 @@ void main() {
     float gg = float(g)/255.0;
     float bb = float(b)/255.0;
 
-    v_Rgb = srgbDecode(vec3(rr,gg,bb));
+    v_Rgb = vec3(rr,gg,bb);
 
 }

client/src/singleplayer.rs

@@ -321,6 +321,13 @@ impl State for SinglePlayer {
             pos_z: 0.0,
             scale: 0.3,
         });
+        models_to_draw.push(crate::render::Model {
+            mesh_id: self.model_registry.get_id_by_name(&"item:ingot_iron".to_owned()).unwrap(),
+            pos_x: 30.0,
+            pos_y: 55.0,
+            pos_z: 30.0,
+            scale: 1.0/32.0,
+        });
         // Draw chunks
         self.world_renderer.render(
             device,

common/src/block/mod.rs

@@ -8,7 +8,7 @@ pub type BlockId = u16;
 #[derive(Debug, Clone, Deserialize)]
 #[serde(rename = "Block")]
 pub enum BlockType {
-    Air,
+    Air, // TODO: skip when deserializing
     NormalCube { face_textures: Vec<String> },
 }
 

common/src/data/mod.rs

@@ -13,6 +13,7 @@ use std::fs;
 use std::io::Read;
 use std::path::PathBuf;
 use texture_packer::{TexturePacker, TexturePackerConfig};
+use crate::item::ItemType;
 
 #[derive(Debug, Clone)]
 pub struct Data {
@@ -92,48 +93,25 @@ pub fn load_data(data_directory: PathBuf) -> Result<Data> {
     let model_knight = load_voxel_model("data/model/chr_knight.vox").unwrap();
     models.register("knight".to_owned(), model_knight)?;
 
-    // Load blocks
-    let mut block_datas: Vec<(String, BlockType)> = Vec::new();
-    let blocks_directory = data_directory.join("blocks");
-    info!(
-        "Loading blocks from directory {}",
-        blocks_directory.display()
-    );
-    for dir_entry in fs::read_dir(blocks_directory).context("couldn't read block directory")? {
-        let dir_entry = dir_entry.context("failed to read directory entry")?;
-        if dir_entry
-            .file_type()
-            .context("failed to get file type")?
-            .is_file()
-        {
-            let file_path = dir_entry.path();
+    // Load items
+    let items_directory = data_directory.join("items");
+    let item_datas: Vec<(String, ItemType)> = load_files_from_folder(items_directory);
 
-            match file_path.extension() {
-                None => panic!("No file extension"),
-                Some(ext) => {
-                    if ext == "ron" {
-                        let mut file = fs::File::open(file_path.clone())
-                            .context("couldn't open .ron block file")?;
-                        let mut buffer = String::new();
-                        file.read_to_string(&mut buffer)?;
-                        block_datas.push((
-                            file_path
-                                .file_stem()
-                                .context("failed to get file stem")?
-                                .to_str()
-                                .unwrap()
-                                .to_owned(),
-                            ron::de::from_str(&buffer)
-                                .context("failed to parse .ron block file")?,
-                        ));
-                    } else {
-                        panic!("Unsupported file extension");
-                    }
-                }
+    // Generate item models
+    for (name, ty) in item_datas.into_iter() {
+        match ty {
+            ItemType::NormalItem { texture } => {
+                let texture_rect = texture_rects[texture_registry.get_id_by_name(&texture).unwrap() as usize];
+                let model = self::vox::item::generate_item_model(texture_rect, &texture_atlas);
+                models.register(format!("item:{}", name), model).expect("Failed to register item model");
             }
         }
     }
 
+    // Load blocks
+    let blocks_directory = data_directory.join("blocks");
+    let block_datas: Vec<(String, BlockType)> = load_files_from_folder(blocks_directory);
+
     info!("Processing collected block and texture data");
     let mut blocks = Registry::default();
     let mut meshes = Vec::new();
@@ -144,7 +122,7 @@ pub fn load_data(data_directory: PathBuf) -> Result<Data> {
             name: "air".to_owned(),
             block_type: BlockType::Air,
         },
-    )?;
+    ).expect("Couldn't register air in the registry.");
     meshes.push(BlockMesh::Empty);
 
     for (name, block_type) in block_datas.into_iter() {
@@ -189,7 +167,7 @@ pub struct TextureRect {
     pub height: f32,
 }
 
-const MAX_TEXTURE_SIZE: u32 = 2048;
+pub const MAX_TEXTURE_SIZE: u32 = 2048;
 
 const TEXTURE_PACKER_CONFIG: TexturePackerConfig = TexturePackerConfig {
     max_width: MAX_TEXTURE_SIZE,
@@ -244,3 +222,65 @@ fn load_textures(
             .collect(),
     ))
 }
+
+/// Load all <name>.ron files from a given folder and parse them into type `T`.
+fn load_files_from_folder<T: serde::de::DeserializeOwned>(
+    directory: PathBuf,
+) -> Vec<(String, T)> {
+    let mut result = Vec::new();
+    info!(
+        "Loading objects of type {} from directory {}",
+        std::any::type_name::<T>(),
+        directory.display(),
+    );
+    for dir_entry in fs::read_dir(directory).expect("Failed to read from directory") {
+        let dir_entry = dir_entry.expect("Failed to read directory entry");
+        if dir_entry
+            .file_type()
+            .expect("Failed to get file type")
+            .is_file()
+        {
+            let file_path = dir_entry.path();
+
+            match file_path.extension() {
+                None => log::warn!("No file extension for file {}, skipping...", file_path.display()),
+                Some(ext) => {
+                    if ext == "ron" {
+                        log::info!("Attempting to read file {}", file_path.display());
+                        let mut file = fs::File::open(file_path.clone())
+                            .expect("Failed to open file");
+                        let mut buffer = String::new();
+                        file.read_to_string(&mut buffer).expect("Failed to read from file");
+                        let file_stem = file_path
+                            .file_stem()
+                            .expect("Failed to get file stem")
+                            .to_str()
+                            .unwrap()
+                            .to_owned();
+
+                        let parsed_file = {
+                            if ext == "ron" {
+                                match ron::de::from_str(&buffer) {
+                                    Ok(x) => x,
+                                    Err(e) => {
+                                        log::error!("Failed to parse RON: {}, skipping...", e);
+                                        continue
+                                    }
+                                }
+                            } else {
+                                unreachable!("No parser for file format");
+                            }
+                        };
+                        result.push((
+                            file_stem,
+                            parsed_file,
+                        ));
+                    } else {
+                        log::warn!("Unsupported file extension {:?}, skipping...", ext); // TODO: display instead of debug
+                    }
+                }
+            }
+        }
+    }
+    result
+}

common/src/data/vox/item.rs

@@ -0,0 +1,36 @@
+use crate::data::{TextureRect, MAX_TEXTURE_SIZE};
+use image::{ImageBuffer, Rgba};
+use crate::data::vox::VoxelModel;
+
+pub fn generate_item_model(texture: TextureRect, atlas: &ImageBuffer<Rgba<u8>, Vec<u8>>) -> VoxelModel {
+    let x = (texture.x * MAX_TEXTURE_SIZE as f32).round() as u32;
+    let y = (texture.y * MAX_TEXTURE_SIZE as f32).round() as u32;
+    let width = (texture.width * MAX_TEXTURE_SIZE as f32).round() as u32;
+    let height = (texture.height * MAX_TEXTURE_SIZE as f32).round() as u32;
+
+    let mut full = Vec::with_capacity((width * height) as usize);
+    let mut voxels = Vec::with_capacity((width * height) as usize);
+
+    for u in x..(x + width) {
+        for v in (y..(y + height)).rev() {
+            let rgba = atlas.get_pixel(u, v);
+            if rgba[3] == 255 { // Not transparent
+                full.push(true);
+                // AGBR
+                voxels.push(((rgba[2] as u32) << 16) + ((rgba[1] as u32) << 8) + rgba[0] as u32);
+            } else {
+                full.push(false);
+                voxels.push(0);
+            }
+        }
+    }
+
+
+    VoxelModel {
+        size_x: width as usize,
+        size_y: height as usize,
+        size_z: 1,
+        voxels,
+        full,
+    }
+}

common/src/data/vox/mod.rs

@@ -2,6 +2,8 @@ use std::fs::File;
 use std::io::Read;
 use std::str::from_utf8;
 
+pub mod item;
+
 const DEFAULT_PALETTE: [u32; 256] = [
     0x00000000, 0xffffffff, 0xffccffff, 0xff99ffff, 0xff66ffff, 0xff33ffff, 0xff00ffff, 0xffffccff,
     0xffccccff, 0xff99ccff, 0xff66ccff, 0xff33ccff, 0xff00ccff, 0xffff99ff, 0xffcc99ff, 0xff9999ff,

common/src/item/mod.rs

@@ -0,0 +1,11 @@
+use serde::Deserialize;
+
+pub type ItemId = u32;
+
+/// The type of an item. It contains the behavior and the texture of the item.
+/// This is the data provided by the creator of the item.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename = "Block")]
+pub enum ItemType {
+    NormalItem { texture: String },
+}

common/src/lib.rs

@@ -2,6 +2,7 @@ pub mod block;
 pub mod collections;
 pub mod data;
 pub mod debug;
+pub mod item;
 pub mod light;
 pub mod network;
 pub mod physics;

data/items/ingot_iron.ron

@@ -0,0 +1,3 @@
+NormalItem(
+    texture: "ingot_iron",
+)