| |
| use mb3_dat::{Limits, Vec3, World}; |
| use std::{collections::HashMap, fmt}; |
| #[derive(Debug, PartialEq, Eq)] |
| pub enum Error { |
| ComputedRequired, |
| InvalidGeometry, |
| NonFinite, |
| Overflow, |
| Limit, |
| Allocation, |
| } |
| impl fmt::Display for Error { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| write!(f, "OBJ: {self:?}") |
| } |
| } |
| impl std::error::Error for Error {} |
| type Result<T> = std::result::Result<T, Error>; |
| struct Output<'a> { |
| bytes: Vec<u8>, |
| limits: &'a Limits, |
| items: usize, |
| owned: usize, |
| error: Option<Error>, |
| } |
| impl fmt::Write for Output<'_> { |
| fn write_str(&mut self, s: &str) -> fmt::Result { |
| let result = (|| { |
| let n = self |
| .bytes |
| .len() |
| .checked_add(s.len()) |
| .ok_or(Error::Overflow)?; |
| if n > self.limits.max_bytes { |
| return Err(Error::Limit); |
| } |
| self.bytes |
| .try_reserve(s.len()) |
| .map_err(|_| Error::Allocation)?; |
| self.bytes.extend_from_slice(s.as_bytes()); |
| Ok(()) |
| })(); |
| if let Err(e) = result { |
| self.error = Some(e); |
| return Err(fmt::Error); |
| } |
| Ok(()) |
| } |
| } |
| impl Output<'_> { |
| fn put(&mut self, args: fmt::Arguments<'_>) -> Result<()> { |
| fmt::write(self, args).map_err(|_| self.error.take().unwrap_or(Error::Overflow)) |
| } |
| fn charge(&mut self, n: usize) -> Result<()> { |
| self.items = self.items.checked_add(n).ok_or(Error::Overflow)?; |
| if self.items > self.limits.max_items { |
| Err(Error::Limit) |
| } else { |
| Ok(()) |
| } |
| } |
| fn vertex(&mut self, v: Vec3) -> Result<()> { |
| key(v)?; |
| self.put(format_args!("v {} {} {}\n", v[0], v[1], v[2])) |
| } |
| } |
| fn key(v: Vec3) -> Result<[u32; 3]> { |
| if !v.iter().all(|n| n.is_finite()) { |
| return Err(Error::NonFinite); |
| } |
| Ok(v.map(|n| if n == 0. { 0 } else { n.to_bits() })) |
| } |
| fn mul(a: usize, b: usize) -> Result<usize> { |
| a.checked_mul(b).ok_or(Error::Overflow) |
| } |
| fn add(a: usize, b: usize) -> Result<usize> { |
| a.checked_add(b).ok_or(Error::Overflow) |
| } |
| pub fn encode(world: &World, limits: &Limits) -> Result<Vec<u8>> { |
| if !world.computed { |
| return Err(Error::ComputedRequired); |
| } |
| let mut o = Output { |
| bytes: Vec::new(), |
| limits, |
| items: 0, |
| owned: 0, |
| error: None, |
| }; |
| let mut base = 1usize; |
| o.charge(add(world.brushes.len(), world.patches.len())?)?; |
| for brush in &world.brushes { |
| o.charge(brush.planes.len())?; |
| o.put(format_args!("#brush\n"))?; |
| let mut map = HashMap::new(); |
| for p in &brush.planes { |
| let vertices = p.polygon.as_ref().ok_or(Error::InvalidGeometry)?; |
| if vertices.len() < 3 { |
| return Err(Error::InvalidGeometry); |
| } |
| o.charge(vertices.len())?; |
| for v in vertices { |
| let k = key(*v)?; |
| if !map.contains_key(&k) { |
| o.owned = add(o.owned, 2 * std::mem::size_of::<([u32; 3], usize)>())?; |
| if o.owned > limits.max_owned_bytes { |
| return Err(Error::Limit); |
| } |
| map.try_reserve(1).map_err(|_| Error::Allocation)?; |
| let id = add(base, map.len())?; |
| map.insert(k, id); |
| o.vertex(*v)?; |
| } |
| } |
| } |
| for p in &brush.planes { |
| o.put(format_args!("f"))?; |
| for v in p.polygon.as_ref().ok_or(Error::InvalidGeometry)? { |
| let id = map.get(&key(*v)?).ok_or(Error::InvalidGeometry)?; |
| o.put(format_args!(" {id}"))?; |
| } |
| o.put(format_args!("\n"))?; |
| } |
| base = add(base, map.len())?; |
| } |
| for p in &world.patches { |
| let data = p.computed.as_ref().ok_or(Error::InvalidGeometry)?; |
| let u = add(mul(p.anchors_u as usize / 2, p.quads_u as usize)?, 1)?; |
| let v = add(mul(p.anchors_v as usize / 2, p.quads_v as usize)?, 1)?; |
| let n = mul(u, v)?; |
| if data.points.len() != n |
| || data.normals.len() != n |
| || p.anchors.len() != mul(p.anchors_u as usize, p.anchors_v as usize)? |
| { |
| return Err(Error::InvalidGeometry); |
| } |
| o.charge(add( |
| add(p.anchors.len(), data.normals.len())?, |
| add(n, mul(u - 1, v - 1)?)?, |
| )?)?; |
| for v in p.anchors.iter().chain(&data.normals) { |
| key(*v)?; |
| } |
| o.put(format_args!("#patch9\n"))?; |
| for point in &data.points { |
| o.vertex(*point)?; |
| } |
| for y in 0..v - 1 { |
| for x in 0..u - 1 { |
| let i = add(base, add(x, mul(y, u)?)?)?; |
| o.put(format_args!( |
| "f {} {} {} {}\n", |
| i, |
| add(i, u)?, |
| add(add(i, u)?, 1)?, |
| add(i, 1)? |
| ))?; |
| } |
| } |
| base = add(base, n)?; |
| } |
| Ok(o.bytes) |
| } |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use mb3_dat::{Brush, Plane}; |
| fn world() -> World { |
| World { |
| computed: true, |
| brushes: vec![Brush { |
| planes: vec![Plane { |
| polygon: Some(vec![[0., 0., 0.], [1., 0., 0.], [0., 1., 0.]]), |
| ..Plane::default() |
| }], |
| }], |
| ..World::default() |
| } |
| } |
| #[test] |
| fn exact_triangle_and_limits() { |
| let w = world(); |
| assert_eq!( |
| encode(&w, &Limits::default()).unwrap(), |
| b"#brush\nv 0 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3\n" |
| ); |
| for l in [ |
| Limits { |
| max_bytes: 2, |
| ..Limits::default() |
| }, |
| Limits { |
| max_items: 1, |
| ..Limits::default() |
| }, |
| Limits { |
| max_owned_bytes: 1, |
| ..Limits::default() |
| }, |
| ] { |
| assert!(encode(&w, &l).is_err()); |
| } |
| } |
| #[test] |
| fn no_global_dedup_and_signed_zero_equality() { |
| let mut w = world(); |
| w.brushes[0].planes.push(Plane { |
| polygon: Some(vec![[-0., 0., 0.], [1., 0., 0.], [0., 1., 0.]]), |
| ..Plane::default() |
| }); |
| w.brushes.push(w.brushes[0].clone()); |
| let s = String::from_utf8(encode(&w, &Limits::default()).unwrap()).unwrap(); |
| assert_eq!(s.lines().filter(|s| s.starts_with("v ")).count(), 6); |
| assert!(s.contains("f 4 5 6")); |
| } |
| #[test] |
| fn invalid_models_refused() { |
| let mut w = world(); |
| w.computed = false; |
| assert_eq!( |
| encode(&w, &Limits::default()).unwrap_err(), |
| Error::ComputedRequired |
| ); |
| w = world(); |
| w.brushes[0].planes[0].polygon.as_mut().unwrap()[0][0] = f32::NAN; |
| assert_eq!( |
| encode(&w, &Limits::default()).unwrap_err(), |
| Error::NonFinite |
| ); |
| w = world(); |
| w.brushes[0].planes[0].polygon = Some(vec![]); |
| assert!(encode(&w, &Limits::default()).is_err()); |
| } |
| } |
|
|
