ase 0.1.0

Rust library to parse Aseprite *ase. files
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

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

use byteorder::{LittleEndian, ReadBytesExt};

use crate::color::Pixels;
use crate::helpers::read_bytes;
use crate::{ColorDepth, Header};

pub enum Cel {
	RawCel {
		width: u16,
		height: u16,
		pixels: Pixels,
	},
	LinkedCel {
		frame_position: u16,
	},
	CompressedImage {
		width: u16,
		height: u16,
		zlib_compressed_data: Vec<u8>,
	},
}

pub struct CelChunk {
	pub layer_index: u16,
	pub x_position: i16,
	pub y_position: i16,
	pub opacity_level: u8,
	pub cel: Cel,
}

impl CelChunk {
	pub fn from_read<R>(read: &mut R, chunk_size: u32, header: &Header) -> io::Result<Self>
	where
		R: Read + Seek,
	{
		let chunk_start = read.seek(SeekFrom::Current(0))?;

		let layer_index = read.read_u16::<LittleEndian>()?;
		let x_position = read.read_i16::<LittleEndian>()?;
		let y_position = read.read_i16::<LittleEndian>()?;
		let opacity_level = read.read_u8()?;
		let cel_type = read.read_u16::<LittleEndian>()?;

		let cel = match cel_type {
			0 => {
				let width = read.read_u16::<LittleEndian>()?;
				let height = read.read_u16::<LittleEndian>()?;

				let pixels_size =
					chunk_start + chunk_size as u64 - read.seek(SeekFrom::Current(0))?;
				let pixels = match header.color_depth {
					ColorDepth::Indexed => Pixels::indexed_from_read(read, pixels_size as usize)?,
					ColorDepth::Grayscale => {
						Pixels::grayscale_from_read(read, pixels_size as usize)?
					}
					ColorDepth::RGBA => Pixels::rgba_from_read(read, pixels_size as usize)?,
				};

				Cel::RawCel {
					width,
					height,
					pixels,
				}
			}
			1 => Cel::LinkedCel {
				frame_position: read.read_u16::<LittleEndian>()?,
			},
			2 => {
				let width = read.read_u16::<LittleEndian>()?;
				let height = read.read_u16::<LittleEndian>()?;

				let data_size =
					chunk_start + chunk_size as u64 - read.seek(SeekFrom::Current(0))?;
				let zlib_compressed_data = read_bytes(read, data_size as usize)?;

				Cel::CompressedImage {
					width,
					height,
					zlib_compressed_data,
				}
			}
			_ => {
				return Err(io::Error::new(
					io::ErrorKind::Other,
					format!("Invalid Cel Type {}", cel_type),
				));
			}
		};

		Ok(Self {
			layer_index,
			x_position,
			y_position,
			opacity_level,
			cel,
		})
	}
}