| |
| #![forbid(unsafe_code)] |
| use std::fmt; |
|
|
| #[derive(Debug, Clone, PartialEq, Eq)] |
| pub struct Error(pub &'static str); |
| impl fmt::Display for Error { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.write_str(self.0) |
| } |
| } |
| impl std::error::Error for Error {} |
| type Result<T> = std::result::Result<T, Error>; |
| fn range(offset: usize, count: usize, stride: usize, end: usize, min: usize) -> Result<()> { |
| let size = count |
| .checked_mul(stride) |
| .ok_or(Error("region size overflow"))?; |
| if (count > 0 && offset < min) || offset.checked_add(size).is_none_or(|v| v > end) { |
| return Err(Error("region outside MD3 bounds")); |
| } |
| Ok(()) |
| } |
| fn int(data: &[u8], offset: usize) -> Result<i32> { |
| let raw = data |
| .get(offset..offset.checked_add(4).ok_or(Error("offset overflow"))?) |
| .ok_or(Error("truncated integer"))?; |
| Ok(i32::from_le_bytes( |
| raw.try_into().map_err(|_| Error("integer width"))?, |
| )) |
| } |
| fn count(data: &[u8], offset: usize) -> Result<usize> { |
| usize::try_from(int(data, offset)?).map_err(|_| Error("negative MD3 count/offset")) |
| } |
| fn float(data: &[u8], offset: usize) -> Result<f32> { |
| let v = f32::from_bits(int(data, offset)? as u32); |
| if !v.is_finite() { |
| return Err(Error("nonfinite MD3 geometry")); |
| } |
| Ok(v) |
| } |
| fn text(data: &[u8], offset: usize, width: usize) -> Result<String> { |
| let raw = data |
| .get(offset..offset.checked_add(width).ok_or(Error("offset overflow"))?) |
| .ok_or(Error("truncated name"))?; |
| let end = raw.iter().position(|&x| x == 0).unwrap_or(raw.len()); |
| Ok(String::from_utf8_lossy(&raw[..end]).into_owned()) |
| } |
|
|
| #[derive(Debug, Clone)] |
| pub struct Surface { |
| pub offset: usize, |
| pub name: String, |
| pub frames: usize, |
| pub shaders: usize, |
| pub vertices: usize, |
| pub triangles: usize, |
| pub triangles_offset: usize, |
| pub shaders_offset: usize, |
| pub uv_offset: usize, |
| pub vertices_offset: usize, |
| pub end: usize, |
| } |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct Vertex { |
| pub packed: [i16; 3], |
| pub normal_word: u16, |
| } |
| impl Vertex { |
| pub fn position(&self) -> [f32; 3] { |
| self.packed.map(|v| f32::from(v) / 64.0) |
| } |
| } |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct Tag { |
| pub name: String, |
| pub origin: [f32; 3], |
| pub axis: [[f32; 3]; 3], |
| } |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct Frame { |
| pub mins: [f32; 3], |
| pub maxs: [f32; 3], |
| pub origin: [f32; 3], |
| pub radius: f32, |
| pub name: String, |
| } |
| pub struct Md3<'a> { |
| data: &'a [u8], |
| pub name: String, |
| pub frames: usize, |
| pub tags: usize, |
| frames_offset: usize, |
| tags_offset: usize, |
| surfaces: Vec<Surface>, |
| } |
| impl<'a> Md3<'a> { |
| pub fn parse(data: &'a [u8]) -> Result<Self> { |
| if data.len() < 108 || &data[..4] != b"IDP3" || int(data, 4)? != 15 { |
| return Err(Error("unsupported MD3 header")); |
| } |
| let frames = count(data, 76)?; |
| let tags = count(data, 80)?; |
| let surface_count = count(data, 84)?; |
| let _skins = count(data, 88)?; |
| let frames_offset = count(data, 92)?; |
| let tags_offset = count(data, 96)?; |
| let mut offset = count(data, 100)?; |
| let end = count(data, 104)?; |
| if end != data.len() { |
| return Err(Error("MD3 declared end differs from file size")); |
| } |
| range(frames_offset, frames, 56, end, 108)?; |
| range( |
| tags_offset, |
| frames |
| .checked_mul(tags) |
| .ok_or(Error("tag count overflow"))?, |
| 112, |
| end, |
| 108, |
| )?; |
| range(offset, surface_count, 108, end, 108)?; |
| let mut surfaces = Vec::with_capacity(surface_count); |
| for _ in 0..surface_count { |
| range(offset, 1, 108, end, 108)?; |
| if &data[offset..offset + 4] != b"IDP3" { |
| return Err(Error("invalid surface signature")); |
| } |
| let s = Surface { |
| offset, |
| name: text(data, offset + 4, 64)?, |
| frames: count(data, offset + 72)?, |
| shaders: count(data, offset + 76)?, |
| vertices: count(data, offset + 80)?, |
| triangles: count(data, offset + 84)?, |
| triangles_offset: count(data, offset + 88)?, |
| shaders_offset: count(data, offset + 92)?, |
| uv_offset: count(data, offset + 96)?, |
| vertices_offset: count(data, offset + 100)?, |
| end: count(data, offset + 104)?, |
| }; |
| if s.frames != frames || s.end < 108 || s.end > end - offset { |
| return Err(Error("invalid surface frames/end")); |
| } |
| range(s.triangles_offset, s.triangles, 12, s.end, 108)?; |
| range(s.shaders_offset, s.shaders, 68, s.end, 108)?; |
| range(s.uv_offset, s.vertices, 8, s.end, 108)?; |
| range( |
| s.vertices_offset, |
| frames |
| .checked_mul(s.vertices) |
| .ok_or(Error("vertex count overflow"))?, |
| 8, |
| s.end, |
| 108, |
| )?; |
| for triangle in 0..s.triangles { |
| let p = offset + s.triangles_offset + triangle * 12; |
| for j in 0..3 { |
| if count(data, p + 4 * j)? >= s.vertices { |
| return Err(Error("triangle outside vertex range")); |
| } |
| } |
| } |
| offset += s.end; |
| surfaces.push(s); |
| } |
| if surface_count > 0 && offset != end { |
| return Err(Error("surface chain differs from EOF")); |
| } |
| let model = Self { |
| data, |
| name: text(data, 8, 64)?, |
| frames, |
| tags, |
| frames_offset, |
| tags_offset, |
| surfaces, |
| }; |
| for index in 0..frames { |
| model.frame(index)?; |
| for tag in 0..tags { |
| model.tag(index, tag)?; |
| } |
| } |
| for (index, surface) in model.surfaces.iter().enumerate() { |
| for vertex in 0..surface.vertices { |
| model.uv(index, vertex)?; |
| } |
| } |
| Ok(model) |
| } |
| pub fn surfaces(&self) -> &[Surface] { |
| &self.surfaces |
| } |
| fn surface(&self, index: usize) -> Result<&Surface> { |
| self.surfaces |
| .get(index) |
| .ok_or(Error("surface index outside bounds")) |
| } |
| pub fn triangle(&self, surface: usize, index: usize) -> Result<[usize; 3]> { |
| let s = self.surface(surface)?; |
| range(index, 1, 1, s.triangles, 0)?; |
| let p = s.offset + s.triangles_offset + 12 * index; |
| Ok([ |
| count(self.data, p)?, |
| count(self.data, p + 4)?, |
| count(self.data, p + 8)?, |
| ]) |
| } |
| pub fn vertex(&self, surface: usize, frame: usize, index: usize) -> Result<Vertex> { |
| let s = self.surface(surface)?; |
| range(frame, 1, 1, s.frames, 0)?; |
| range(index, 1, 1, s.vertices, 0)?; |
| let p = s.offset + s.vertices_offset + (frame * s.vertices + index) * 8; |
| let mut packed = [0; 3]; |
| for (j, value) in packed.iter_mut().enumerate() { |
| *value = i16::from_le_bytes( |
| self.data[p + 2 * j..p + 2 * j + 2] |
| .try_into() |
| .map_err(|_| Error("vertex width"))?, |
| ); |
| } |
| Ok(Vertex { |
| packed, |
| normal_word: u16::from_le_bytes( |
| self.data[p + 6..p + 8] |
| .try_into() |
| .map_err(|_| Error("normal width"))?, |
| ), |
| }) |
| } |
| pub fn uv(&self, surface: usize, index: usize) -> Result<[f32; 2]> { |
| let s = self.surface(surface)?; |
| range(index, 1, 1, s.vertices, 0)?; |
| let p = s.offset + s.uv_offset + index * 8; |
| Ok([float(self.data, p)?, float(self.data, p + 4)?]) |
| } |
| pub fn shader(&self, surface: usize, index: usize) -> Result<(String, i32)> { |
| let s = self.surface(surface)?; |
| range(index, 1, 1, s.shaders, 0)?; |
| let p = s.offset + s.shaders_offset + index * 68; |
| Ok((text(self.data, p, 64)?, int(self.data, p + 64)?)) |
| } |
| pub fn frame(&self, index: usize) -> Result<Frame> { |
| range(index, 1, 1, self.frames, 0)?; |
| let p = self.frames_offset + index * 56; |
| Ok(Frame { |
| mins: [ |
| float(self.data, p)?, |
| float(self.data, p + 4)?, |
| float(self.data, p + 8)?, |
| ], |
| maxs: [ |
| float(self.data, p + 12)?, |
| float(self.data, p + 16)?, |
| float(self.data, p + 20)?, |
| ], |
| origin: [ |
| float(self.data, p + 24)?, |
| float(self.data, p + 28)?, |
| float(self.data, p + 32)?, |
| ], |
| radius: float(self.data, p + 36)?, |
| name: text(self.data, p + 40, 16)?, |
| }) |
| } |
| pub fn tag(&self, frame: usize, index: usize) -> Result<Tag> { |
| range(frame, 1, 1, self.frames, 0)?; |
| range(index, 1, 1, self.tags, 0)?; |
| let p = self.tags_offset + (frame * self.tags + index) * 112; |
| Ok(Tag { |
| name: text(self.data, p, 64)?, |
| origin: [ |
| float(self.data, p + 64)?, |
| float(self.data, p + 68)?, |
| float(self.data, p + 72)?, |
| ], |
| axis: [ |
| [ |
| float(self.data, p + 76)?, |
| float(self.data, p + 80)?, |
| float(self.data, p + 84)?, |
| ], |
| [ |
| float(self.data, p + 88)?, |
| float(self.data, p + 92)?, |
| float(self.data, p + 96)?, |
| ], |
| [ |
| float(self.data, p + 100)?, |
| float(self.data, p + 104)?, |
| float(self.data, p + 108)?, |
| ], |
| ], |
| }) |
| } |
| } |
|
|
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| fn put(d: &mut [u8], p: usize, v: i32) { |
| d[p..p + 4].copy_from_slice(&v.to_le_bytes()); |
| } |
| fn fixture() -> Vec<u8> { |
| let mut d = vec![0; 276]; |
| d[..4].copy_from_slice(b"IDP3"); |
| put(&mut d, 4, 15); |
| for (p, v) in [ |
| (76, 1), |
| (84, 1), |
| (92, 108), |
| (96, 164), |
| (100, 164), |
| (104, 276), |
| ] { |
| put(&mut d, p, v); |
| } |
| d[164..168].copy_from_slice(b"IDP3"); |
| put(&mut d, 236, 1); |
| for (p, v) in [(252, 108), (256, 108), (260, 108), (264, 108), (268, 112)] { |
| put(&mut d, p, v); |
| } |
| d |
| } |
| #[test] |
| fn empty_surface_is_bounded() { |
| let d = fixture(); |
| let m = Md3::parse(&d).unwrap(); |
| assert_eq!(m.surfaces().len(), 1); |
| assert!(m.vertex(0, 0, 0).is_err()); |
| } |
| #[test] |
| fn truncation_rejects() { |
| let d = fixture(); |
| assert!(Md3::parse(&d[..275]).is_err()); |
| } |
| #[test] |
| fn signature_and_version_reject() { |
| for p in [0, 4] { |
| let mut d = fixture(); |
| d[p] = 0; |
| assert!(Md3::parse(&d).is_err()); |
| } |
| } |
| #[test] |
| fn negative_counts_reject() { |
| let mut d = fixture(); |
| put(&mut d, 76, -1); |
| assert!(Md3::parse(&d).is_err()); |
| } |
| #[test] |
| fn outside_regions_reject() { |
| let mut d = fixture(); |
| put(&mut d, 260, 10000); |
| assert!(Md3::parse(&d).is_err()); |
| } |
| #[test] |
| fn frame_accessor_bounds_reject() { |
| let d = fixture(); |
| let m = Md3::parse(&d).unwrap(); |
| assert!(m.frame(1).is_err()); |
| assert!(m.tag(0, 0).is_err()); |
| } |
| #[test] |
| fn nonfinite_frame_rejects() { |
| let mut d = fixture(); |
| put(&mut d, 108, f32::NAN.to_bits() as i32); |
| assert!(Md3::parse(&d).is_err()); |
| } |
| #[test] |
| fn region_arithmetic_overflow_rejects() { |
| assert!(range(usize::MAX, 1, 4, usize::MAX, 0).is_err()); |
| assert!(range(0, usize::MAX, 4, usize::MAX, 0).is_err()); |
| } |
| #[test] |
| fn triangle_index_outside_vertex_count_rejects() { |
| let mut d = fixture(); |
| d.resize(300, 0); |
| for (p, v) in [ |
| (104, 300), |
| (244, 1), |
| (248, 1), |
| (252, 108), |
| (260, 120), |
| (264, 128), |
| (268, 136), |
| (280, 1), |
| ] { |
| put(&mut d, p, v); |
| } |
| assert!(Md3::parse(&d).is_err()); |
| } |
| #[test] |
| fn signed_coordinate_extrema_and_normal_word_preserved() { |
| let v = Vertex { |
| packed: [i16::MIN, i16::MAX, -1], |
| normal_word: 0xabcd, |
| }; |
| assert_eq!(v.position(), [-512.0, 511.984375, -0.015625]); |
| assert_eq!(v.normal_word, 0xabcd); |
| } |
| } |
|
|
