rbx_mesh 0.8.0

Rust parser for Roblox mesh files.
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use super::roblox_bit_reader::{BitCounterError, RobloxBitReader};

#[derive(Debug, Eq, PartialEq)]
pub enum Symbol {
	// 1 bit
	Continue, // 0b0
	// 3 bits
	Split, // 0b1_00
	Left,  // 0b1_01
	Right, // 0b1_10
	End,   // 0b1_11
}

pub struct SymbolReader<'a> {
	bit_reader: RobloxBitReader<'a>,
}
impl<'a> SymbolReader<'a> {
	pub fn new(bytes: &'a [u8], bits: u32) -> Result<Self, BitCounterError> {
		let bit_reader = RobloxBitReader::new(bytes, bits)?;
		Ok(Self { bit_reader })
	}
	pub const fn remaining_bits(&self) -> u32 {
		self.bit_reader.remaining_bits()
	}
	pub fn read(&mut self) -> Result<Symbol, BitCounterError> {
		if self.bit_reader.read(1)? == 0 {
			return Ok(Symbol::Continue);
		}
		let bits = self.bit_reader.read(2)?;
		Ok(match (bits & 0b10 != 0, bits & 0b01 != 0) {
			(false, false) => Symbol::Split,
			(false, true) => Symbol::Left,
			(true, false) => Symbol::Right,
			(true, true) => Symbol::End,
		})
	}
}

#[test]
fn read_symbols() {
	// 2 C_C_R_C_S_L_E_C
	// 1 C_C_R_C_S_L_E_C
	// 4 C_C_R_C_S_L_E_C
	// 3     R_C_S_L_E_C
	// BYTES are read in the order 4,3,2,1, 8,7,6,5 msb-first
	#[rustfmt::skip]
	const BYTES: [u8; 8] = [
		0b0_101_111_0, 0b0_0_110_0_10, // [4, 3]
		0b0_101_111_0, 0b0_0_110_0_10, // [2, 1]
		0b0_101_111_0, 0b0_0_110_0_10, // [8, 7]
		0b0_101_111_0,     0b110_0_10, // [6, 5]
	];
	// truncate last word by 2 bits
	let mut r = SymbolReader::new(&BYTES, 62).unwrap();
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Right));
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Split));
	assert_eq!(r.read(), Ok(Symbol::Left));
	assert_eq!(r.read(), Ok(Symbol::End));
	assert_eq!(r.read(), Ok(Symbol::Continue));

	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Right));
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Split));
	assert_eq!(r.read(), Ok(Symbol::Left));
	assert_eq!(r.read(), Ok(Symbol::End));
	assert_eq!(r.read(), Ok(Symbol::Continue));

	// Truncation affects this section
	assert_eq!(r.read(), Ok(Symbol::Right));
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Split));
	assert_eq!(r.read(), Ok(Symbol::Left));
	assert_eq!(r.read(), Ok(Symbol::End));
	assert_eq!(r.read(), Ok(Symbol::Continue));

	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Right));
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Ok(Symbol::Split));
	assert_eq!(r.read(), Ok(Symbol::Left));
	assert_eq!(r.read(), Ok(Symbol::End));
	assert_eq!(r.read(), Ok(Symbol::Continue));
	assert_eq!(r.read(), Err(BitCounterError::NotEnoughBits));
}
#[test]
fn empirical() {
	const BYTES: [u8; 4] = [183, 219, 55, 0];
	let mut r = SymbolReader::new(&BYTES, 22).unwrap();
	// dump partial symbol
	assert_eq!(r.bit_reader.read(1), Ok(1));

	assert_eq!(r.read(), Ok(Symbol::Left));
	assert_eq!(r.read(), Ok(Symbol::End));
	assert_eq!(r.read(), Ok(Symbol::Left));
	assert_eq!(r.read(), Ok(Symbol::Left));
	assert_eq!(r.read(), Ok(Symbol::Right));
	assert_eq!(r.read(), Ok(Symbol::Right));
	assert_eq!(r.read(), Ok(Symbol::End));
	assert_eq!(r.read(), Err(BitCounterError::NotEnoughBits));
}