pak 0.7.4

An easy-to-use data pak format for games.
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

use {
    crate::compression::{BrotliParams, Compression},
    serde::Deserialize,
};

/// Holds a description of top-level content files which simply group other asset files for ease of
/// use.
#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq)]
pub struct Content {
    compression: Option<CompressionType>,

    // Brotli-specific compression parameter
    #[serde(rename = "buffer-size")]
    buffer_size: Option<usize>,

    // Brotli-specific compression parameter
    quality: Option<u32>,

    // Brotli-specific compression parameter
    #[serde(rename = "window-size")]
    window_size: Option<u32>,

    // Tables must follow values
    #[serde(default, rename = "group")]
    groups: Box<[Group]>,
}

impl Content {
    /// An iterator of grouped content file descriptions.
    #[allow(unused)]
    pub fn groups(&self) -> impl Iterator<Item = &Group> {
        self.groups.iter()
    }

    pub(crate) fn compression(&self) -> Option<Compression> {
        self.compression.map(|compression| match compression {
            CompressionType::Brotli => Compression::Brotli(BrotliParams {
                buffer_size: self
                    .buffer_size
                    .unwrap_or_else(|| BrotliParams::default().buffer_size),
                quality: self
                    .quality
                    .unwrap_or_else(|| BrotliParams::default().quality),
                window_size: self
                    .window_size
                    .unwrap_or_else(|| BrotliParams::default().window_size),
            }),
            CompressionType::Snap => Compression::Snap,
        })
    }
}

#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq)]
pub enum CompressionType {
    /// Higher compression ratio but slower to decode and encode.
    #[serde(rename = "brotli")]
    Brotli,
    /// Lower compression ratio but faster to decode and encode.
    #[serde(rename = "snap")]
    Snap,
}

/// Holds a description of asset files.
#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq)]
pub struct Group {
    #[serde(default)]
    assets: Vec<String>,

    #[serde(default = "Group::default_enabled")]
    enabled: bool,

    #[serde(default)]
    exclude: Vec<String>,
}

impl Group {
    const DEFAULT_ENABLED: bool = true;

    /// Individual asset file specification globs.
    ///
    /// May be a filename, might be folder/**/other.jpeg
    #[allow(unused)]
    pub fn asset_globs(&self) -> impl Iterator<Item = &String> {
        self.assets.iter()
    }

    const fn default_enabled() -> bool {
        Self::DEFAULT_ENABLED
    }

    /// Allows a group to be selectively removed with a single flag, as opposed to physically
    /// removing a group from the content file.
    ///
    /// This is useful for debugging.
    #[allow(unused)]
    pub fn enabled(&self) -> bool {
        self.enabled
    }

    /// Individual asset file specification globs to exclude from baking.
    ///
    /// May be a filename, might be folder/**/other.jpeg
    #[allow(unused)]
    pub fn exclude_globs(&self) -> impl Iterator<Item = &String> {
        self.exclude.iter()
    }
}

#[cfg(test)]
mod tests {
    use super::Content;

    #[test]
    fn content_deserializes_without_groups() {
        let content = toml::from_str::<Content>("compression = 'snap'")
            .expect("content groups should be optional");

        assert_eq!(content.groups().count(), 0);
    }
}