libgm 0.5.1

A tool for modding, unpacking and decompiling GameMaker 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

pub mod fill;
pub mod line;

use crate::prelude::*;
use crate::util::init::vec_with_capacity;
use crate::wad::deserialize::reader::DataReader;
use crate::wad::elements::GMElement;
use crate::wad::serialize::builder::DataBuilder;

#[derive(Debug, Clone, PartialEq)]
pub struct StyleGroup<T> {
    pub fill_styles: Vec<fill::Data>,
    pub line_styles: Vec<line::Data>,
    pub subshapes: Vec<T>,
}

impl<T: GMElement> GMElement for StyleGroup<T> {
    fn deserialize(reader: &mut DataReader) -> Result<Self> {
        let fill_data_count = reader.read_count("YYSWF Style Group Fill Data")?;
        let line_style_count = reader.read_count("YYSWF Style Group Line Style")?;
        let subshape_count = reader.read_count("YYSWF Style Group Subshape")?;

        let mut fill_styles: Vec<fill::Data> = vec_with_capacity(fill_data_count)?;
        for _ in 0..fill_data_count {
            fill_styles.push(fill::Data::deserialize(reader)?);
        }

        let mut line_styles: Vec<line::Data> = vec_with_capacity(line_style_count)?;
        for _ in 0..line_style_count {
            line_styles.push(line::Data::deserialize(reader)?);
        }

        let mut subshapes: Vec<T> = vec_with_capacity(subshape_count)?;
        for _ in 0..subshape_count {
            subshapes.push(T::deserialize(reader)?);
        }

        Ok(Self { fill_styles, line_styles, subshapes })
    }

    fn serialize(&self, builder: &mut DataBuilder) -> Result<()> {
        builder.write_usize(self.fill_styles.len())?;
        builder.write_usize(self.line_styles.len())?;
        builder.write_usize(self.subshapes.len())?;
        for fill_data in &self.fill_styles {
            fill_data.serialize(builder)?;
        }
        for line_data in &self.line_styles {
            line_data.serialize(builder)?;
        }
        for subshape in &self.subshapes {
            subshape.serialize(builder)?;
        }
        Ok(())
    }
}