libgm 0.7.1

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

// SPDX-License-Identifier: GPL-3.0-only
use crate::prelude::*;
use crate::wad::build::builder::DataBuilder;
use crate::wad::elem::GMElement;
use crate::wad::elem::game_object::GameObject;
use crate::wad::parse::reader::DataReader;
use crate::wad::reference::GMRef;

/// "Viewports and Cameras"
#[derive(Debug, Clone, PartialEq)]
pub struct RoomView {
    /// "Enable Viewports"
    pub enabled: bool,

    /// "Camera Properties - X Pos"
    pub view_x: i32,

    /// "Camera Properties - Y Pos"
    pub view_y: i32,

    /// "Camera Properties - Width"
    pub view_width: i32,

    /// "Camera Properties - Height"
    pub view_height: i32,

    /// "Viewport Properties - X Pos"
    pub port_x: i32,

    /// "Viewport Properties - Y Pos"
    pub port_y: i32,

    /// "Viewport Properties - Width"
    pub port_width: i32,

    /// "Viewport Properties - Height"
    pub port_height: i32,

    /// "Object Following - Horizontal Border"
    pub border_x: u32,

    /// "Object Following - Vertical Border"
    pub border_y: u32,

    /// "Object Following - Horizontal Speed"
    pub speed_x: i32,

    /// "Object Following - Vertical Speed"
    pub speed_y: i32,

    /// The game object which this camera view follows.
    ///
    /// "Object Following - (Game Object Selector)"
    pub object: GMRef<GameObject>,
}

impl GMElement for RoomView {
    fn deserialize(reader: &mut DataReader) -> Result<Self> {
        let enabled = reader.read_bool32()?;
        let view_x = reader.read_i32()?;
        let view_y = reader.read_i32()?;
        let view_width = reader.read_i32()?;
        let view_height = reader.read_i32()?;
        let port_x = reader.read_i32()?;
        let port_y = reader.read_i32()?;
        let port_width = reader.read_i32()?;
        let port_height = reader.read_i32()?;
        let border_x = reader.read_u32()?;
        let border_y = reader.read_u32()?;
        let speed_x = reader.read_i32()?;
        let speed_y = reader.read_i32()?;
        let object: GMRef<GameObject> = reader.read_resource_by_id()?;

        Ok(Self {
            enabled,
            view_x,
            view_y,
            view_width,
            view_height,
            port_x,
            port_y,
            port_width,
            port_height,
            border_x,
            border_y,
            speed_x,
            speed_y,
            object,
        })
    }

    fn serialize(&self, builder: &mut DataBuilder) -> Result<()> {
        builder.write_bool32(self.enabled);
        builder.write_i32(self.view_x);
        builder.write_i32(self.view_y);
        builder.write_i32(self.view_width);
        builder.write_i32(self.view_height);
        builder.write_i32(self.port_x);
        builder.write_i32(self.port_y);
        builder.write_i32(self.port_width);
        builder.write_i32(self.port_height);
        builder.write_u32(self.border_x);
        builder.write_u32(self.border_y);
        builder.write_i32(self.speed_x);
        builder.write_i32(self.speed_y);
        builder.write_resource_id(self.object);
        Ok(())
    }
}