add ply support

Author: Snowiiii

Cargo.lock

@@ -14,10 +14,12 @@ repository = "https://github.com/ventengine/Modelz"
 actively-developed = {}
 
 [features]
-default = ["obj", "gltf", "stl"]
+default = ["obj", "gltf", "stl", "ply"]
 obj = ["dep:tobj"]
 gltf = ["dep:gltf"]
 stl = ["dep:stl_io"]
+ply = ["dep:ply-rs"]
+
 
 [dependencies]
 log = "0.4"
@@ -28,4 +30,6 @@ gltf = {version = "1.4.0", optional = true }
 # OBJ Wavefront
 tobj = { version = "4.0.0", features = ["async"], optional = true }
 # STL
-stl_io = { version = "0.7.0", optional = true }
+stl_io = { version = "0.7.0", optional = true }
+# PLY
+ply-rs = { version = "0.1.3", optional = true }

Cargo.toml

@@ -21,6 +21,7 @@ let model = Model3D::from_format("model", ModelFormat::OBJ).except("Failed to lo
 - [x] Wavefront OBJ
 - [x] glTF 2.0 
 - [x] STL
+- [x] PLY
 
 ### Contributing
 

README.md

@@ -9,7 +9,10 @@ use gltf::Mesh;
 use crate::{Indices, Model3D, ModelError, Vertex};
 
 pub fn load(path: &Path) -> Result<Model3D, ModelError> {
-    let gltf = gltf::Gltf::from_reader(fs::File::open(path).unwrap()).unwrap();
+    let gltf = gltf::Gltf::from_reader(
+        fs::File::open(path).map_err(|e| ModelError::OpenFile(e.to_string()))?,
+    )
+    .map_err(|e| ModelError::ModelParsing(e.to_string()))?;
 
     let path = path.parent().unwrap_or_else(|| Path::new("./"));
 

src/gltf.rs

@@ -5,6 +5,8 @@ mod gltf;
 #[cfg(feature = "obj")]
 mod obj;
 #[cfg(feature = "stl")]
+mod ply;
+#[cfg(feature = "ply")]
 mod stl;
 
 pub struct Model3D {
@@ -62,6 +64,8 @@ impl Model3D {
             ModelFormat::GLTF => return gltf::load(path.as_ref()),
             #[cfg(feature = "stl")]
             ModelFormat::STL => return stl::load(path.as_ref()),
+            #[cfg(feature = "ply")]
+            ModelFormat::PLY => return ply::load(path.as_ref()),
         }
     }
 }
@@ -75,9 +79,12 @@ pub enum ModelFormat {
     #[cfg(feature = "gltf")]
     // gltf 2.0, .gltf | .glb
     GLTF,
-    // STL .stl
     #[cfg(feature = "stl")]
+    // STL .stl
     STL,
+    #[cfg(feature = "ply")]
+    // Polygon File Format .ply
+    PLY,
 }
 
 #[derive(Debug)]
@@ -86,6 +93,8 @@ pub enum ModelError {
     UnknowFormat,
     // Given file does not exist
     FileNotExists,
+    // Failed to open file
+    OpenFile(String),
     // Error while loading general 3D File
     ModelParsing(String),
     // Error loading Material

src/lib.rs

@@ -0,0 +1,179 @@
+use std::{fs::File, path::Path};
+
+extern crate ply_rs;
+use ply_rs::{
+    self as ply,
+    ply::{Property, PropertyAccess},
+};
+
+use crate::{Model3D, ModelError};
+
+#[derive(Debug, Default, Clone, Copy)]
+struct Vertex {
+    x: f32,
+    y: f32,
+    z: f32,
+    x_norm: Option<f32>,
+    y_norm: Option<f32>,
+    z_norm: Option<f32>,
+    tex_x: Option<f32>,
+    tex_y: Option<f32>,
+}
+
+impl PropertyAccess for Vertex {
+    fn new() -> Self {
+        Vertex {
+            ..Default::default()
+        }
+    }
+    fn set_property(&mut self, key: String, property: Property) {
+        match (key.as_ref(), property) {
+            ("x", Property::Float(v)) => self.x = v,
+            ("y", Property::Float(v)) => self.y = v,
+            ("z", Property::Float(v)) => self.z = v,
+
+            ("nx", Property::Float(v)) => self.x_norm = Some(v),
+            ("ny", Property::Float(v)) => self.y_norm = Some(v),
+            ("nz", Property::Float(v)) => self.z_norm = Some(v),
+            // NOTE: Blender3D exports texture coordinates as s,t tuples
+            ("u" | "s" | "tx" | "texture_u", Property::Float(v)) => self.tex_x = Some(v),
+            ("v" | "t" | "ty" | "texture_v", Property::Float(v)) => self.tex_y = Some(v),
+            (k, _) => eprintln!("Vertex: Unexpected key/value combination: key: {}", k),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Face {
+    vertex_index: Vec<u32>,
+}
+
+impl PropertyAccess for Face {
+    fn new() -> Self {
+        Face {
+            vertex_index: Vec::new(),
+        }
+    }
+    fn set_property(&mut self, key: String, property: Property) {
+        match (key.as_ref(), property) {
+            ("vertex_index" | "vertex_indices", Property::ListUInt(vec)) => self.vertex_index = vec,
+            (k, _) => eprintln!("Face: Unexpected key/value combination: key: {}", k),
+        }
+    }
+}
+
+pub fn load(path: &Path) -> Result<Model3D, ModelError> {
+    let mut file = File::open(path).map_err(|e| ModelError::OpenFile(e.to_string()))?;
+    let mut reader = std::io::BufReader::new(&mut file);
+
+    // Create a parser for each struct. Parsers are cheap objects.
+    let vertex_parser = ply::parser::Parser::<Vertex>::new();
+    let face_parser = ply::parser::Parser::<Face>::new();
+
+    // lets first consume the header
+    // We also could use `face_parser`, The configuration is a parser's only state.
+    // The reading position only depends on `f`.
+    let header = vertex_parser.read_header(&mut reader).unwrap();
+
+    // Depending on the header, read the data into our structs..
+    let mut vertex_list = Vec::new();
+    let mut face_list = Vec::new();
+    for (_ignore_key, element) in &header.elements {
+        // we could also just parse them in sequence, but the file format might change
+        match element.name.as_ref() {
+            "vertex" => {
+                vertex_list = vertex_parser
+                    .read_payload_for_element(&mut reader, element, &header)
+                    .unwrap();
+            }
+            "face" => {
+                face_list = face_parser
+                    .read_payload_for_element(&mut reader, element, &header)
+                    .unwrap();
+            }
+            _ => panic!("Enexpeced element!"),
+        }
+    }
+    let mut vertices = Vec::new();
+    for face in face_list {
+        // Every face (triangle) has 3 Vertices
+        let vertex = vertex_list[face.vertex_index[0] as usize];
+        let vertex1 = vertex_list[face.vertex_index[1] as usize];
+        let vertex2 = vertex_list[face.vertex_index[2] as usize];
+
+        let mut normal = None;
+        let mut tex_coord = None;
+        if let Some(x) = vertex.x_norm {
+            if let Some(y) = vertex.z_norm {
+                if let Some(z) = vertex.z_norm {
+                    normal = Some([x, y, z])
+                }
+            }
+        }
+        if let Some(x) = vertex.tex_x {
+            if let Some(y) = vertex.tex_y {
+                tex_coord = Some([x, y])
+            }
+        }
+
+        let v1 = crate::Vertex {
+            position: [vertex.x, vertex.y, vertex.z],
+            tex_coord,
+            color: None,
+            normal,
+        };
+        if let Some(x) = vertex1.x_norm {
+            if let Some(y) = vertex1.z_norm {
+                if let Some(z) = vertex1.z_norm {
+                    normal = Some([x, y, z])
+                }
+            }
+        }
+        if let Some(x) = vertex1.tex_x {
+            if let Some(y) = vertex1.tex_y {
+                tex_coord = Some([x, y])
+            }
+        }
+        let v2 = crate::Vertex {
+            position: [vertex1.x, vertex1.y, vertex1.z],
+            tex_coord,
+            color: None,
+            normal,
+        };
+        if let Some(x) = vertex2.x_norm {
+            if let Some(y) = vertex2.z_norm {
+                if let Some(z) = vertex2.z_norm {
+                    normal = Some([x, y, z])
+                }
+            }
+        }
+        if let Some(x) = vertex2.tex_x {
+            if let Some(y) = vertex2.tex_y {
+                tex_coord = Some([x, y])
+            }
+        }
+        let v3 = crate::Vertex {
+            position: [vertex2.x, vertex2.y, vertex2.z],
+            tex_coord,
+            color: None,
+            normal,
+        };
+
+        vertices.push(v1);
+        vertices.push(v2);
+        vertices.push(v3);
+    }
+    let mesh = crate::Mesh {
+        vertices,
+        indices: None,
+        material_index: None,
+        mode: crate::RenderMode::TriangleFan,
+        name: None,
+    };
+
+    Ok(Model3D {
+        meshes: vec![mesh],
+        materials: vec![],
+        format: crate::ModelFormat::PLY,
+    })
+}

src/ply.rs

@@ -3,7 +3,9 @@ use std::{fs::File, path::Path};
 use crate::{Model3D, ModelError, Vertex};
 
 pub fn load(path: &Path) -> Result<Model3D, ModelError> {
-    let stl = stl_io::read_stl(&mut File::open(path).unwrap()).unwrap();
+    let stl =
+        stl_io::read_stl(&mut File::open(path).map_err(|e| ModelError::OpenFile(e.to_string()))?)
+            .map_err(|e| ModelError::ModelParsing(e.to_string()))?;
 
     let mut vertices = Vec::new();
     for face in stl.faces {

src/stl.rs

@@ -0,0 +1,17 @@
+#[cfg(test)]
+mod ply {
+    use modelz::Model3D;
+
+    #[test]
+    fn load_ply() {
+        let model_path = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/cube.ply");
+
+        let model = Model3D::from_format(model_path, modelz::ModelFormat::PLY)
+            .expect("Failed to load ply model");
+        for mesh in model.meshes {
+            for vert in mesh.vertices {
+                println!("{:?}", vert)
+            }
+        }
+    }
+}