mod anim;
mod humanoid;
mod scene;
pub use anim::{anim_clip_cases, anim_gltf_cases};
pub use humanoid::anim_humanoid_cases;
pub use scene::scene_cases;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct SceneCase {
pub meter: u8,
pub flags: u8,
pub profile: Vec<u8>,
pub data: Vec<u8>,
}
impl SceneCase {
#[must_use]
pub fn encode(&self) -> Vec<u8> {
let len = self.profile.len().min(usize::from(u16::MAX));
let mut out = vec![self.meter, self.flags];
out.extend_from_slice(&u16::try_from(len).unwrap_or(u16::MAX).to_le_bytes());
out.extend_from_slice(&self.profile[..len]);
out.extend_from_slice(&self.data);
out
}
#[must_use]
pub fn decode(input: &[u8]) -> Self {
let mut case = Self {
meter: input.first().copied().unwrap_or(0),
flags: input.get(1).copied().unwrap_or(0),
..Self::default()
};
if let Some(header) = input.get(2..4) {
let len = usize::from(u16::from_le_bytes([header[0], header[1]]));
let end = 4usize.saturating_add(len).min(input.len());
case.profile = input[4..end].to_vec();
case.data = input[end..].to_vec();
}
case
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Row {
pub level: u8,
pub meta_flag: i32,
pub ty: Vec<u8>,
pub name: Vec<u8>,
}
impl Row {
#[must_use]
pub fn new(level: u8, ty: &[u8], name: &[u8], meta_flag: i32) -> Self {
Self {
level,
meta_flag,
ty: ty.to_vec(),
name: name.to_vec(),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct RefType {
pub class: Vec<u8>,
pub namespace: Vec<u8>,
pub assembly: Vec<u8>,
pub rows: Option<Vec<Row>>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct TreeCase {
pub flags: u8,
pub start: i8,
pub rows: Vec<Row>,
pub refs: Vec<RefType>,
pub data: Vec<u8>,
}
impl TreeCase {
pub const BIG_ENDIAN: u8 = 1;
pub const REFS_ABSENT: u8 = 2;
pub const REFS_NO_FILE: u8 = 4;
pub const STREAM: u8 = 8;
pub const LOSSLESS: u8 = 16;
pub const PYTHON: u8 = 32;
pub const SMALL_MEMORY: u8 = 64;
pub const BYTES_IO: u8 = 128;
#[must_use]
pub fn has(&self, bit: u8) -> bool {
self.flags & bit != 0
}
#[must_use]
pub fn encode(&self) -> Vec<u8> {
let mut out = vec![self.flags, self.start.to_le_bytes()[0]];
put_rows(&mut out, &self.rows);
let refs = &self.refs[..self.refs.len().min(usize::from(u8::MAX))];
out.push(u8::try_from(refs.len()).unwrap_or(u8::MAX));
for r in refs {
put_str(&mut out, &r.class);
put_str(&mut out, &r.namespace);
put_str(&mut out, &r.assembly);
match &r.rows {
Some(rows) => {
out.push(1);
put_rows(&mut out, rows);
}
None => out.push(0),
}
}
out.extend_from_slice(&self.data);
out
}
#[must_use]
pub fn decode(input: &[u8]) -> Self {
let mut c = Cursor(input);
let mut case = Self {
flags: c.u8().unwrap_or(0),
start: c.u8().map_or(0, |b| i8::from_le_bytes([b])),
..Self::default()
};
let Some(rows) = c.rows() else {
return case;
};
case.rows = rows;
let Some(n) = c.u8() else {
return case;
};
for _ in 0..n {
let Some(r) = c.ref_type() else {
return case;
};
case.refs.push(r);
}
case.data = c.0.to_vec();
case
}
}
#[must_use]
pub fn blob_case(format: u8, big_endian: bool, tree: &[u8]) -> Vec<u8> {
let mut out = vec![format, u8::from(big_endian)];
out.extend_from_slice(tree);
out
}
#[must_use]
pub fn lz4_case(declared: u32, block: &[u8]) -> Vec<u8> {
let mut out = declared.to_le_bytes().to_vec();
out.extend_from_slice(block);
out
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct TextureCase {
pub format: i32,
pub width: i32,
pub height: i32,
pub platform: i32,
pub meter: u8,
pub blob: Option<Vec<u8>>,
pub data: Vec<u8>,
}
impl TextureCase {
pub const NO_BLOB: u8 = u8::MAX;
#[must_use]
pub fn encode(&self) -> Vec<u8> {
let mut out = Vec::new();
for v in [self.format, self.width, self.height, self.platform] {
out.extend_from_slice(&v.to_le_bytes());
}
out.push(self.meter);
match &self.blob {
Some(b) => {
let b = &b[..b.len().min(usize::from(Self::NO_BLOB - 1))];
out.push(u8::try_from(b.len()).unwrap_or(0));
out.extend_from_slice(b);
}
None => out.push(Self::NO_BLOB),
}
out.extend_from_slice(&self.data);
out
}
#[must_use]
pub fn decode(input: &[u8]) -> Self {
let mut c = Cursor(input);
let (Some(format), Some(width), Some(height), Some(platform), Some(meter)) =
(c.i32(), c.i32(), c.i32(), c.i32(), c.u8())
else {
return Self::default();
};
let mut case = Self {
format,
width,
height,
platform,
meter,
..Self::default()
};
case.blob = match c.u8() {
None => return case,
Some(Self::NO_BLOB) => None,
Some(n) => match c.take(usize::from(n)) {
Some(b) => Some(b.to_vec()),
None => return case,
},
};
case.data = c.0.to_vec();
case
}
}
fn put_str(out: &mut Vec<u8>, s: &[u8]) {
let s = &s[..s.len().min(usize::from(u8::MAX))];
out.push(u8::try_from(s.len()).unwrap_or(u8::MAX));
out.extend_from_slice(s);
}
fn put_rows(out: &mut Vec<u8>, rows: &[Row]) {
let rows = &rows[..rows.len().min(usize::from(u16::MAX))];
out.extend_from_slice(&u16::try_from(rows.len()).unwrap_or(u16::MAX).to_le_bytes());
for r in rows {
out.push(r.level);
out.extend_from_slice(&r.meta_flag.to_le_bytes());
put_str(out, &r.ty);
put_str(out, &r.name);
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct MeshCase {
pub flags: u8,
pub meter: u8,
pub version: [u16; 3],
pub version_type: u8,
pub version_number: u8,
pub resource: Vec<u8>,
pub value: TreeCase,
}
impl MeshCase {
pub const SPRITE: u8 = 1;
pub const BIG_ENDIAN: u8 = 2;
pub const RESOURCES: u8 = 4;
#[must_use]
pub fn has(&self, bit: u8) -> bool {
self.flags & bit != 0
}
#[must_use]
pub fn encode(&self) -> Vec<u8> {
let mut out = vec![self.flags, self.meter];
for v in self.version {
out.extend_from_slice(&v.to_le_bytes());
}
out.extend_from_slice(&[self.version_type, self.version_number]);
let r = &self.resource[..self.resource.len().min(usize::from(u16::MAX))];
out.extend_from_slice(&u16::try_from(r.len()).unwrap_or(u16::MAX).to_le_bytes());
out.extend_from_slice(r);
out.extend_from_slice(&self.value.encode());
out
}
#[must_use]
pub fn decode(input: &[u8]) -> Self {
let mut c = Cursor(input);
let (Some(flags), Some(meter), Some(major), Some(minor), Some(build)) =
(c.u8(), c.u8(), c.u16(), c.u16(), c.u16())
else {
return Self::default();
};
let (Some(version_type), Some(version_number)) = (c.u8(), c.u8()) else {
return Self::default();
};
let mut case = Self {
flags,
meter,
version: [major, minor, build],
version_type,
version_number,
..Self::default()
};
let Some(resource) = c.u16().and_then(|n| c.take(usize::from(n))) else {
return case;
};
case.resource = resource.to_vec();
case.value = TreeCase::decode(c.0);
case
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ShaderCase {
pub version: (u32, u32),
pub meter: u8,
pub blob: Vec<u8>,
}
impl ShaderCase {
#[must_use]
pub fn encode(&self) -> Vec<u8> {
let mut out = self.version.0.to_le_bytes().to_vec();
out.extend_from_slice(&self.version.1.to_le_bytes());
out.push(self.meter);
out.extend_from_slice(&self.blob);
out
}
#[must_use]
pub fn decode(input: &[u8]) -> Self {
let mut c = Cursor(input);
let (Some(major), Some(minor), Some(meter)) = (c.u32(), c.u32(), c.u8()) else {
return Self::default();
};
Self {
version: (major, minor),
meter,
blob: c.0.to_vec(),
}
}
}
struct Cursor<'a>(&'a [u8]);
impl Cursor<'_> {
fn take(&mut self, n: usize) -> Option<&[u8]> {
let (head, rest) = self.0.split_at_checked(n)?;
self.0 = rest;
Some(head)
}
fn u8(&mut self) -> Option<u8> {
self.take(1)?.first().copied()
}
fn u16(&mut self) -> Option<u16> {
Some(u16::from_le_bytes(self.take(2)?.try_into().ok()?))
}
fn i32(&mut self) -> Option<i32> {
Some(i32::from_le_bytes(self.take(4)?.try_into().ok()?))
}
fn u32(&mut self) -> Option<u32> {
Some(u32::from_le_bytes(self.take(4)?.try_into().ok()?))
}
fn str(&mut self) -> Option<Vec<u8>> {
let n = self.u8()?;
Some(self.take(usize::from(n))?.to_vec())
}
fn rows(&mut self) -> Option<Vec<Row>> {
let n = u16::from_le_bytes(self.take(2)?.try_into().ok()?);
let mut rows = Vec::new();
for _ in 0..n {
let level = self.u8()?;
let meta_flag = i32::from_le_bytes(self.take(4)?.try_into().ok()?);
let ty = self.str()?;
let name = self.str()?;
rows.push(Row {
level,
meta_flag,
ty,
name,
});
}
Some(rows)
}
fn ref_type(&mut self) -> Option<RefType> {
let class = self.str()?;
let namespace = self.str()?;
let assembly = self.str()?;
let rows = if self.u8()? & 1 == 1 {
Some(self.rows()?)
} else {
None
};
Some(RefType {
class,
namespace,
assembly,
rows,
})
}
}
#[cfg(test)]
mod tests {
use super::{MeshCase, RefType, Row, TextureCase, TreeCase, blob_case, lz4_case};
fn case() -> TreeCase {
TreeCase {
flags: TreeCase::BIG_ENDIAN | TreeCase::PYTHON,
start: -3,
rows: vec![
Row::new(0, b"Base", b"Base", 0),
Row::new(1, b"int", b"x", 0x4000),
],
refs: vec![
RefType {
class: b"A".to_vec(),
namespace: b"n".to_vec(),
assembly: b"a".to_vec(),
rows: Some(vec![Row::new(0, b"A", b"Base", 0)]),
},
RefType::default(),
],
data: vec![1, 2, 3, 4],
}
}
#[test]
fn a_case_decodes_to_what_was_encoded() {
let c = case();
assert_eq!(TreeCase::decode(&c.encode()), c);
assert!(c.has(TreeCase::PYTHON) && !c.has(TreeCase::STREAM));
}
#[test]
fn a_cut_case_keeps_what_it_reaches_and_empties_the_rest() {
let c = case();
let bytes = c.encode();
for n in 0..bytes.len() {
let d = TreeCase::decode(&bytes[..n]);
assert!(d.data.len() <= c.data.len());
}
let cut = TreeCase::decode(&bytes[..bytes.len() - 1]);
assert_eq!((cut.rows, cut.refs), (c.rows.clone(), c.refs.clone()));
assert_eq!(cut.data, [1, 2, 3]);
let rows_only = TreeCase::decode(&bytes[..bytes.len() - 20]);
assert_eq!(rows_only.rows, c.rows);
assert!(rows_only.refs.is_empty() && rows_only.data.is_empty());
assert_eq!(TreeCase::decode(&[]), TreeCase::default());
}
#[test]
fn long_strings_and_lists_are_cut_to_what_their_lengths_hold() {
let c = TreeCase {
rows: vec![Row::new(0, &[b'x'; 300], b"Base", 0)],
..TreeCase::default()
};
let d = TreeCase::decode(&c.encode());
assert_eq!(d.rows[0].ty.len(), 255);
assert_eq!(d.rows[0].name, b"Base");
}
#[test]
fn a_texture_case_decodes_to_what_was_encoded_and_a_cut_one_to_less() {
let c = TextureCase {
format: 25,
width: -3,
height: 16384,
platform: 38,
meter: 2,
blob: Some(vec![0; 12]),
data: vec![1, 2, 3],
};
let bytes = c.encode();
assert_eq!(bytes.len(), 17 + 1 + 12 + 3);
assert_eq!(TextureCase::decode(&bytes), c);
let none = TextureCase {
blob: None,
..c.clone()
};
assert_eq!(TextureCase::decode(&none.encode()), none);
assert_eq!(TextureCase::decode(&bytes[..16]), TextureCase::default());
let header = TextureCase::decode(&bytes[..20]);
assert_eq!(
(header.width, header.blob, header.data),
(-3, None, Vec::new())
);
assert_eq!(TextureCase::decode(&bytes[..31]).data, [1]);
}
#[test]
fn a_mesh_case_decodes_to_what_was_encoded_and_a_cut_one_to_less() {
let c = MeshCase {
flags: MeshCase::SPRITE | MeshCase::RESOURCES,
meter: 9,
version: [2019, 4, 40],
version_type: 3,
version_number: 1,
resource: vec![5; 3],
value: case(),
};
let bytes = c.encode();
assert_eq!(bytes.len(), 10 + 2 + 3 + c.value.encode().len());
assert_eq!(MeshCase::decode(&bytes), c);
assert!(c.has(MeshCase::SPRITE) && !c.has(MeshCase::BIG_ENDIAN));
assert_eq!(MeshCase::decode(&bytes[..9]), MeshCase::default());
let header = MeshCase::decode(&bytes[..13]);
assert_eq!(
(header.version, header.resource, header.value),
([2019, 4, 40], Vec::new(), TreeCase::default())
);
let cut = MeshCase::decode(&bytes[..bytes.len() - 1]);
assert_eq!((cut.resource, cut.value.data), (vec![5; 3], vec![1, 2, 3]));
}
#[test]
fn the_blob_and_lz4_cases_put_their_header_first() {
assert_eq!(blob_case(19, true, &[9]), [19, 1, 9]);
assert_eq!(lz4_case(0x0102_0304, &[7]), [4, 3, 2, 1, 7]);
}
}