diff options
Diffstat (limited to 'src/gfx/map')
| -rw-r--r-- | src/gfx/map/atlas.rs | 111 | ||||
| -rw-r--r-- | src/gfx/map/mesh.rs | 125 |
2 files changed, 236 insertions, 0 deletions
diff --git a/src/gfx/map/atlas.rs b/src/gfx/map/atlas.rs new file mode 100644 index 0000000..920fbb4 --- /dev/null +++ b/src/gfx/map/atlas.rs @@ -0,0 +1,111 @@ +use super::{super::media::MediaMgr, AtlasSlice, CUBE}; +use mt_net::NodeDef; +use rand::Rng; +use std::collections::HashMap; + +pub(super) fn create_atlas( + nodes: &mut HashMap<u16, NodeDef>, + media: &MediaMgr, +) -> (image::RgbaImage, Vec<AtlasSlice>) { + let mut rng = rand::thread_rng(); + let mut allocator = guillotiere::SimpleAtlasAllocator::new(guillotiere::size2(1, 1)); + let mut textures = Vec::new(); + + for node in nodes.values_mut() { + let tiles = std::iter::empty() + .chain(node.tiles.iter_mut()) + .chain(node.overlay_tiles.iter_mut()) + .chain(node.special_tiles.iter_mut()); + + let load_texture = |texture: &str| { + let payload = media + .get(texture) + .ok_or_else(|| format!("texture not found: {texture}"))?; + + image::load_from_memory(payload) + .or_else(|_| image::load_from_memory_with_format(payload, image::ImageFormat::Tga)) + .map_err(|e| format!("failed to load texture {texture}: {e}")) + .map(|x| image::imageops::flip_vertical(&x)) + }; + + let mut make_texture = |texture: &str| { + texture + .split('^') + .map(|part| match load_texture(part) { + Ok(v) => v, + Err(e) => { + if !texture.is_empty() && !texture.contains('[') { + eprintln!("{e}"); + } + + let mut img = image::RgbImage::new(1, 1); + rng.fill(&mut img.get_pixel_mut(0, 0).0); + + image::DynamicImage::from(img).to_rgba8() + } + }) + .reduce(|mut base, top| { + image::imageops::overlay(&mut base, &top, 0, 0); + base + }) + .unwrap() + }; + + let mut id_map = HashMap::new(); + + for tile in tiles { + tile.texture.custom = *id_map.entry(tile.texture.name.clone()).or_insert_with(|| { + let img = make_texture(&tile.texture.name); + + let dimensions = img.dimensions(); + let size = guillotiere::size2(dimensions.0 as i32, dimensions.1 as i32); + + loop { + match allocator.allocate(size) { + None => { + let mut atlas_size = allocator.size(); + atlas_size.width *= 2; + atlas_size.height *= 2; + allocator.grow(atlas_size); + } + Some(rect) => { + let id = textures.len(); + textures.push((img, rect)); + return id; + } + } + } + }) + } + } + + let size = allocator.size(); + let mut atlas = image::RgbaImage::new(size.width as u32, size.height as u32); + + let slices = textures + .into_iter() + .map(|(img, rect)| { + let w = size.width as f32; + let h = size.height as f32; + + let x = (rect.min.x as f32 / w)..(rect.max.x as f32 / w); + let y = (rect.min.y as f32 / h)..(rect.max.y as f32 / h); + + use image::GenericImage; + atlas + .copy_from(&img, rect.min.x as u32, rect.min.y as u32) + .unwrap(); + + use lerp::Lerp; + use std::array::from_fn as array; + + let rect = [x, y]; + let cube_tex_coords = + array(|f| array(|v| array(|i| rect[i].start.lerp(rect[i].end, CUBE[f][v].1[i])))); + + AtlasSlice { cube_tex_coords } + }) + .collect(); + + (atlas, slices) +} diff --git a/src/gfx/map/mesh.rs b/src/gfx/map/mesh.rs new file mode 100644 index 0000000..0befb1e --- /dev/null +++ b/src/gfx/map/mesh.rs @@ -0,0 +1,125 @@ +use super::{LeavesMode, MapRenderSettings, MeshMakeInfo, Vertex, CUBE}; +use cgmath::Point3; +use mt_net::MapBlock; +use std::ops::Deref; +use std::sync::Arc; + +#[derive(Clone)] +pub(super) struct MeshData { + pub vertices: Vec<Vertex>, + pub vertices_blend: Vec<Vertex>, +} + +impl MeshData { + pub fn new(cap: usize) -> Self { + Self { + vertices: Vec::with_capacity(cap), + vertices_blend: Vec::with_capacity(cap), + } + } + + pub fn cap(&self) -> usize { + std::cmp::max(self.vertices.capacity(), self.vertices_blend.capacity()) + } +} + +pub(super) fn create_mesh( + buffer_cap: &mut usize, + mkinfo: Arc<MeshMakeInfo>, + settings: &MapRenderSettings, + pos: Point3<i16>, + block: Box<MapBlock>, +) -> (Point3<i16>, MeshData) { + let mkinfo = mkinfo.deref(); + let mut buffer = MeshData::new(*buffer_cap); + + for (index, content) in block.param_0.iter().enumerate() { + let def = match &mkinfo.nodes[*content as usize] { + Some(x) => x, + None => continue, + }; + + use mt_net::{DrawType, Param1Type}; + use std::array::from_fn as array; + + let mut tiles = &def.tiles; + let mut draw_type = def.draw_type; + + match draw_type { + DrawType::AllFacesOpt => { + draw_type = match settings.leaves { + LeavesMode::Opaque => DrawType::Cube, + LeavesMode::Simple => { + tiles = &def.special_tiles; + + DrawType::GlassLike + } + LeavesMode::Fancy => DrawType::AllFaces, + }; + } + DrawType::None => continue, + _ => {} + } + + let light = match def.param1_type { + Param1Type::Light => block.param_1[index] as f32 / 15.0, + _ => 1.0, + }; + + let pos: [i16; 3] = array(|i| ((index >> (4 * i)) & 0xf) as i16); + + for (f, face) in CUBE.iter().enumerate() { + let dir = FACE_DIR[f]; + let npos: [i16; 3] = array(|i| dir[i] + pos[i]); + if npos.iter().all(|x| (0..16).contains(x)) { + let nindex = npos[0] | (npos[1] << 4) | (npos[2] << 8); + + if let Some(ndef) = &mkinfo.nodes[block.param_0[nindex as usize] as usize] { + if ndef.draw_type == DrawType::Cube { + continue; + } + } + } + + let tile = &tiles[f]; + let texture = mkinfo.textures[tile.texture.custom].cube_tex_coords[f]; + + let mut add_vertex = |vertex: (usize, &([f32; 3], [f32; 2]))| { + /*println!( + "{:?} {:?} {:?} {:?}", + (vertex.1[0], vertex.1[1]), + (rect[0].start, rect[1].start), + (rect[0].end, rect[1].end), + ( + vertex.1[0].lerp(rect[0].start, rect[0].end), + vertex.1[1].lerp(rect[1].start, rect[1].end) + ) + );*/ + + buffer.vertices.push(Vertex { + pos: array(|i| pos[i] as f32 - 8.5 + vertex.1 .0[i]), + tex_coords: texture[vertex.0], + light, + }); + }; + + face.iter().enumerate().for_each(&mut add_vertex); + /*if !backface_cull { + face.iter().enumerate().rev().for_each(&mut add_vertex); + }*/ + } + } + + *buffer_cap = buffer.cap(); + (pos, buffer) +} + +#[rustfmt::skip] +const FACE_DIR: [[i16; 3]; 6] = [ + [ 0, 1, 0], + [ 0, -1, 0], + [ 1, 0, 0], + [-1, 0, 0], + [ 0, 0, 1], + [ 0, 0, -1], +]; |