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

use std::io::{self, Read, Seek, SeekFrom};

use bitflags::bitflags;
use byteorder::{LittleEndian, ReadBytesExt};

use crate::helpers::read_string;

bitflags! {
	pub struct Flags: u32 {
		const IsNinePatchesSlice = 1;
		const HasPivotInformation = 2;
	}
}

pub struct NinePatchesInfo {
	pub x_position: i32,
	pub y_position: i32,
	pub width: u32,
	pub height: u32,
}

pub struct PivotInfo {
	pub x_position: i32,
	pub y_position: i32,
}

pub struct SliceKey {
	pub frame_number: u32,
	pub x_origin: i32,
	pub y_origin: i32,
	pub width: u32,
	pub height: u32,
	pub nine_patches_info: Option<NinePatchesInfo>,
	pub pivot_info: Option<PivotInfo>,
}

pub struct SliceChunk {
	pub number_of_slice_keys: u32,
	pub flags: Flags,
	pub name: String,
	pub keys: Vec<SliceKey>,
}

impl SliceChunk {
	pub fn from_read<R>(read: &mut R) -> io::Result<Self>
	where
		R: Read + Seek,
	{
		let number_of_slice_keys = read.read_u32::<LittleEndian>()?;
		let flags = Flags::from_bits_truncate(read.read_u32::<LittleEndian>()?);
		read.seek(SeekFrom::Current(4))?;
		let name = read_string(read)?;
		let mut keys = Vec::with_capacity(number_of_slice_keys as usize);
		for _ in 0..number_of_slice_keys {
			let frame_number = read.read_u32::<LittleEndian>()?;
			let x_origin = read.read_i32::<LittleEndian>()?;
			let y_origin = read.read_i32::<LittleEndian>()?;
			let width = read.read_u32::<LittleEndian>()?;
			let height = read.read_u32::<LittleEndian>()?;
			let nine_patches_info = if flags.contains(Flags::IsNinePatchesSlice) {
				Some(NinePatchesInfo {
					x_position: read.read_i32::<LittleEndian>()?,
					y_position: read.read_i32::<LittleEndian>()?,
					width: read.read_u32::<LittleEndian>()?,
					height: read.read_u32::<LittleEndian>()?,
				})
			} else {
				None
			};
			let pivot_info = if flags.contains(Flags::HasPivotInformation) {
				Some(PivotInfo {
					x_position: read.read_i32::<LittleEndian>()?,
					y_position: read.read_i32::<LittleEndian>()?,
				})
			} else {
				None
			};

			keys.push(SliceKey {
				frame_number,
				x_origin,
				y_origin,
				width,
				height,
				nine_patches_info,
				pivot_info,
			});
		}

		Ok(Self {
			number_of_slice_keys,
			flags,
			name,
			keys,
		})
	}
}