85 lines
3.1 KiB
Rust
85 lines
3.1 KiB
Rust
//! Module containing the logic for Wavefront OBJ serialization.
|
|
|
|
use std::io::Write;
|
|
|
|
use model;
|
|
|
|
use exporter::ExportError;
|
|
use exporter::ElementSerializer;
|
|
use parser::Element;
|
|
use parser::Element::{Vertex, TextureCoordinate, Normal, UseMaterial, Face};
|
|
|
|
|
|
/// Serializer for elements using the wavefront obj format.
|
|
pub struct ObjElementSerializer {
|
|
|
|
}
|
|
|
|
impl ObjElementSerializer {
|
|
/// Create an obj element serializer.
|
|
pub fn new() -> ObjElementSerializer {
|
|
ObjElementSerializer {
|
|
|
|
}
|
|
}
|
|
|
|
/// Writes a face to a writable output.
|
|
pub fn face_to_string(&self, f: model::face::Face) -> String {
|
|
|
|
if f.a.texture_coordinate.is_none() && f.a.normal.is_none() {
|
|
// Only vertices
|
|
format!("f {} {} {}", f.a.vertex + 1, f.b.vertex + 1, f.c.vertex + 1)
|
|
} else if f.a.normal.is_none() {
|
|
// Vertices + tex coords
|
|
format!("f {}/{} {}/{} {}/{}",
|
|
f.a.vertex + 1, f.a.texture_coordinate.unwrap() + 1,
|
|
f.b.vertex + 1, f.b.texture_coordinate.unwrap() + 1,
|
|
f.c.vertex + 1, f.c.texture_coordinate.unwrap() + 1)
|
|
} else if f.a.texture_coordinate.is_none() {
|
|
// Vertices + normals
|
|
format!("f {}//{} {}//{} {}//{}",
|
|
f.a.vertex + 1, f.a.normal.unwrap() + 1,
|
|
f.b.vertex + 1, f.b.normal.unwrap() + 1,
|
|
f.c.vertex + 1, f.c.normal.unwrap() + 1)
|
|
} else {
|
|
// All
|
|
format!("f {}/{}/{} {}/{}/{} {}/{}/{}",
|
|
f.a.vertex + 1, f.a.texture_coordinate.unwrap() + 1, f.a.normal.unwrap() + 1,
|
|
f.b.vertex + 1, f.b.texture_coordinate.unwrap() + 1, f.b.normal.unwrap() + 1,
|
|
f.c.vertex + 1, f.c.texture_coordinate.unwrap() + 1, f.c.normal.unwrap() + 1)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
impl ElementSerializer for ObjElementSerializer {
|
|
/// Serializes an element using the wavefront obj format.
|
|
///
|
|
/// ```
|
|
/// # use model_converter::math::vector::Vector3;
|
|
/// # use model_converter::parser::Element::Vertex;
|
|
/// # use model_converter::exporter::obj::ObjElementSerializer;
|
|
/// use model_converter::exporter::ElementSerializer;
|
|
/// let s = ObjElementSerializer::new();
|
|
/// let vertex = Vertex(Vector3::new(1.0, 2.0, 3.0));
|
|
/// let mut output = vec![];
|
|
/// let serialized = s.serialize(vertex, &mut output).ok().unwrap();
|
|
/// let result = String::from_utf8(output).unwrap();
|
|
/// assert_eq!(result, "v 1 2 3\n");
|
|
/// ```
|
|
fn serialize<W: Write>(&self, element: Element, output: &mut W) -> Result<usize, ExportError> {
|
|
|
|
let string = match element {
|
|
Vertex(v) => format!("v {} {} {}", v.x(), v.y(), v.z()),
|
|
TextureCoordinate(vt) => format!("vt {} {}", vt.x(), vt.y()),
|
|
Normal(n) => format!("vn {} {} {}", n.x(), n.y(), n.z()),
|
|
Face(f) => self.face_to_string(f),
|
|
UseMaterial(ref n) => format!("usemtl {}", n),
|
|
_ => return Ok(0),
|
|
};
|
|
|
|
writeln!(output, "{}", string)?;
|
|
Ok(string.len() + 1)
|
|
}
|
|
}
|