mjcf-rs 0.34.0

Pure-Rust parser for the MuJoCo MJCF XML format.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! Parser for MuJoCo's custom binary `.msh` mesh format.
//!
//! Layout (little-endian):
//! ```text
//! i32 nvertex
//! i32 nnormal
//! i32 ntexcoord
//! i32 nface
//! f32[nvertex * 3]   positions (x, y, z)
//! f32[nnormal * 3]   normals  (x, y, z)
//! f32[ntexcoord * 2] texcoords (u, v)
//! i32[nface * 3]     triangle indices
//! ```
//!
//! Only the positions and faces are required for collision; normals and
//! texcoords are returned for callers that want them.

use std::io::Read;

use byteorder::{LittleEndian, ReadBytesExt};

/// A parsed `.msh` file.
#[derive(Clone, Debug)]
pub struct MshMesh {
    /// Vertex positions, flat `[x0, y0, z0, x1, y1, z1, …]`.
    pub vertices: Vec<f32>,
    /// Vertex normals (may be empty).
    pub normals: Vec<f32>,
    /// Texture coordinates (may be empty).
    pub texcoords: Vec<f32>,
    /// Triangle indices.
    pub faces: Vec<u32>,
}

/// Parse a `.msh` file from raw bytes.
pub fn parse(bytes: &[u8]) -> std::io::Result<MshMesh> {
    let mut cur = bytes;
    let nvertex = cur.read_i32::<LittleEndian>()? as usize;
    let nnormal = cur.read_i32::<LittleEndian>()? as usize;
    let ntexcoord = cur.read_i32::<LittleEndian>()? as usize;
    let nface = cur.read_i32::<LittleEndian>()? as usize;

    let mut vertices = vec![0.0f32; nvertex * 3];
    cur.read_exact(bytemuck_safe_cast(&mut vertices))?;
    let mut normals = vec![0.0f32; nnormal * 3];
    cur.read_exact(bytemuck_safe_cast(&mut normals))?;
    let mut texcoords = vec![0.0f32; ntexcoord * 2];
    cur.read_exact(bytemuck_safe_cast(&mut texcoords))?;
    let mut faces = vec![0i32; nface * 3];
    {
        // i32 chunks; LE.
        for f in faces.iter_mut() {
            *f = cur.read_i32::<LittleEndian>()?;
        }
    }
    Ok(MshMesh {
        vertices,
        normals,
        texcoords,
        faces: faces.into_iter().map(|i| i as u32).collect(),
    })
}

fn bytemuck_safe_cast(slice: &mut [f32]) -> &mut [u8] {
    let len = std::mem::size_of_val(slice);
    let ptr = slice.as_mut_ptr() as *mut u8;
    // Safety: f32 has no invalid bit patterns, and the slice borrows for
    // exactly its lifetime.
    unsafe { std::slice::from_raw_parts_mut(ptr, len) }
}

/// Read a `.msh` file from disk.
pub fn parse_file(path: impl AsRef<std::path::Path>) -> std::io::Result<MshMesh> {
    let bytes = std::fs::read(path)?;
    parse(&bytes)
}