Basic plantlike drawtype

1 files changed, 71 insertions, 35 deletions

diff --git a/src/gfx/map/mesh.rs b/src/gfx/map/mesh.rs
index 3d56ad8..c9b7a84 100644
--- a/src/gfx/map/mesh.rs
+++ b/src/gfx/map/mesh.rs
@@ -1,5 +1,5 @@
 use super::{LeavesMode, MapRenderSettings, MeshgenInfo, Vertex, CUBE, FACE_DIR};
-use cgmath::Point3;
+use cgmath::{Deg, Matrix3, Point3, Vector3};
 use mt_net::MapBlock;
 
 #[derive(Clone)]
@@ -70,51 +70,87 @@ pub(super) fn create_mesh(
 
         let pos: [i16; 3] = array(|i| ((index >> (4 * i)) & 0xf) as i16);
 
-        for (f, face) in CUBE.iter().enumerate() {
-            if draw_type == DrawType::Cube || draw_type == DrawType::Liquid {
-                let c = [1, 1, 0, 0, 2, 2][f];
+        if draw_type == DrawType::Plant {
+            let f = 2;
+            let face = &CUBE[f];
 
-                let mut nblk = block;
-                let mut npos = pos;
-                npos[c] += FACE_DIR[f][c];
+            let tile = &tiles[f];
+            let texture = mkinfo.textures[tile.texture.custom].cube_tex_coords[f];
+
+            let mut add_vertex = |mat: Matrix3<f32>, vertex: (usize, &([f32; 3], [f32; 2]))| {
+                let point = Point3::new(pos[0] as f32, pos[1] as f32, pos[2] as f32)
+                    + mat
+                        * (Vector3::new(vertex.1 .0[0], vertex.1 .0[1], vertex.1 .0[2])
+                            - Vector3::new(0.5, 0.0, 0.0));
 
-                if !(0..16).contains(&npos[c]) {
-                    nblk = match nbors[f].as_ref() {
-                        Some(x) => x,
-                        None => continue,
-                    };
+                vertices.push(Vertex {
+                    pos: [point.x, point.y, point.z],
+                    tex_coords: texture[vertex.0],
+                    light,
+                });
+            };
 
-                    npos[c] = (npos[c] + 16) % 16;
+            let mut add_vertices = |mat| {
+                face.iter().enumerate().for_each(|x| add_vertex(mat, x));
+                if !tile.flags.contains(mt_net::TileFlag::BackfaceCull) {
+                    face.iter()
+                        .enumerate()
+                        .rev()
+                        .for_each(|x| add_vertex(mat, x));
                 }
+            };
+
+            add_vertices(Matrix3::from_angle_y(Deg(45.0)));
+            add_vertices(Matrix3::from_angle_y(Deg(135.0)));
+        } else {
+            for (f, face) in CUBE.iter().enumerate() {
+                if draw_type == DrawType::Cube || draw_type == DrawType::Liquid {
+                    let c = [1, 1, 0, 0, 2, 2][f];
+
+                    let mut nblk = block;
+                    let mut npos = pos;
+                    npos[c] += FACE_DIR[f][c];
 
-                let nidx = npos[0] | (npos[1] << 4) | (npos[2] << 8);
-                let ncontent = nblk.param_0[nidx as usize];
+                    if !(0..16).contains(&npos[c]) {
+                        nblk = match nbors[f].as_ref() {
+                            Some(x) => x,
+                            None => continue,
+                        };
 
-                if let Some(ndef) = &mkinfo.nodes[ncontent as usize] {
-                    if match draw_type {
-                        DrawType::Cube => ndef.draw_type == DrawType::Cube,
-                        DrawType::Liquid => ndef.draw_type == DrawType::Cube || ncontent == content,
-                        _ => false,
-                    } {
-                        continue;
+                        npos[c] = (npos[c] + 16) % 16;
+                    }
+
+                    let nidx = npos[0] | (npos[1] << 4) | (npos[2] << 8);
+                    let ncontent = nblk.param_0[nidx as usize];
+
+                    if let Some(ndef) = &mkinfo.nodes[ncontent as usize] {
+                        if match draw_type {
+                            DrawType::Cube => ndef.draw_type == DrawType::Cube,
+                            DrawType::Liquid => {
+                                ndef.draw_type == DrawType::Cube || ncontent == content
+                            }
+                            _ => false,
+                        } {
+                            continue;
+                        }
                     }
                 }
-            }
 
-            let tile = &tiles[f];
-            let texture = mkinfo.textures[tile.texture.custom].cube_tex_coords[f];
+                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]))| {
-                vertices.push(Vertex {
-                    pos: array(|i| pos[i] as f32 + vertex.1 .0[i]),
-                    tex_coords: texture[vertex.0],
-                    light,
-                });
-            };
+                let mut add_vertex = |vertex: (usize, &([f32; 3], [f32; 2]))| {
+                    vertices.push(Vertex {
+                        pos: array(|i| pos[i] as f32 + vertex.1 .0[i]),
+                        tex_coords: texture[vertex.0],
+                        light,
+                    });
+                };
 
-            face.iter().enumerate().for_each(&mut add_vertex);
-            if !tile.flags.contains(mt_net::TileFlag::BackfaceCull) {
-                face.iter().enumerate().rev().for_each(&mut add_vertex);
+                face.iter().enumerate().for_each(&mut add_vertex);
+                if !tile.flags.contains(mt_net::TileFlag::BackfaceCull) {
+                    face.iter().enumerate().rev().for_each(&mut add_vertex);
+                }
             }
         }
     }