assetc 0.2.0

Reads the files assetc builds and packs: textures, materials, meshes, animations, fonts, atlases and data
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Bounds-checked little-endian reads; every reader goes through these, so bad input is an
//! error, never a panic.

use crate::{Error, Result};

/// `bytes` of format `file`, read at absolute offsets.
#[derive(Clone, Copy)]
pub(crate) struct Bytes<'a> {
    pub bytes: &'a [u8],
    pub file: &'static str,
}

impl<'a> Bytes<'a> {
    pub fn new(bytes: &'a [u8], file: &'static str) -> Self {
        Self { bytes, file }
    }

    pub fn err(&self, message: impl Into<String>) -> Error {
        Error::format(self.file, message)
    }

    pub fn slice(&self, at: usize, len: usize) -> Result<&'a [u8]> {
        at.checked_add(len)
            .and_then(|end| self.bytes.get(at..end))
            .ok_or_else(|| {
                self.err(format!(
                    "{len} bytes at {at} run past the end ({} bytes)",
                    self.bytes.len()
                ))
            })
    }

    pub fn array<const N: usize>(&self, at: usize) -> Result<[u8; N]> {
        Ok(self.slice(at, N)?.try_into().expect("N bytes"))
    }

    pub fn u8(&self, at: usize) -> Result<u8> {
        Ok(self.array::<1>(at)?[0])
    }

    pub fn u16(&self, at: usize) -> Result<u16> {
        self.array(at).map(u16::from_le_bytes)
    }

    pub fn u32(&self, at: usize) -> Result<u32> {
        self.array(at).map(u32::from_le_bytes)
    }

    pub fn i32(&self, at: usize) -> Result<i32> {
        self.array(at).map(i32::from_le_bytes)
    }

    pub fn u64(&self, at: usize) -> Result<u64> {
        self.array(at).map(u64::from_le_bytes)
    }

    pub fn i64(&self, at: usize) -> Result<i64> {
        self.array(at).map(i64::from_le_bytes)
    }

    pub fn f32(&self, at: usize) -> Result<f32> {
        self.array(at).map(f32::from_le_bytes)
    }

    pub fn f64(&self, at: usize) -> Result<f64> {
        self.array(at).map(f64::from_le_bytes)
    }

    /// `N` consecutive f32s.
    pub fn f32s<const N: usize>(&self, at: usize) -> Result<[f32; N]> {
        let mut out = [0.0; N];
        for (i, v) in out.iter_mut().enumerate() {
            *v = self.f32(at + i * 4)?;
        }
        Ok(out)
    }

    /// The `stride`-byte records of the whole payload; its size must be a multiple of
    /// `stride`.
    pub fn records(&self, stride: usize) -> Result<impl Iterator<Item = Bytes<'a>> + 'a> {
        if !self.bytes.len().is_multiple_of(stride) {
            return Err(self.err(format!(
                "{} bytes are not a whole number of {stride}-byte records",
                self.bytes.len()
            )));
        }
        let file = self.file;
        Ok(self
            .bytes
            .chunks_exact(stride)
            .map(move |bytes| Bytes { bytes, file }))
    }

    /// Exactly `count` records of `stride` bytes.
    pub fn records_n(
        &self,
        stride: usize,
        count: usize,
    ) -> Result<impl Iterator<Item = Bytes<'a>> + 'a> {
        let needed = stride
            .checked_mul(count)
            .ok_or_else(|| self.err("record count overflows"))?;
        if self.bytes.len() < needed {
            return Err(self.err(format!(
                "{count} records of {stride} bytes need {needed} bytes, have {}",
                self.bytes.len()
            )));
        }
        let file = self.file;
        Ok(self.bytes[..needed]
            .chunks_exact(stride)
            .map(move |bytes| Bytes { bytes, file }))
    }

    /// UTF-8 text at `at` of `len` bytes.
    pub fn text(&self, at: usize, len: usize) -> Result<String> {
        let bytes = self.slice(at, len)?;
        std::str::from_utf8(bytes)
            .map(str::to_owned)
            .map_err(|_| self.err(format!("text at {at} is not UTF-8")))
    }

    /// Text referenced as `offset` u32 and `len` u32 at `at` in this record, into `strings`.
    pub fn text_ref(&self, at: usize, strings: Bytes<'_>) -> Result<String> {
        strings.text(self.u32(at)? as usize, self.u32(at + 4)? as usize)
    }
}