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
121
122
123
|
use crate::{
format::ser::{ConstSizeSerExt, Ser, Sink, Small, Source},
helpers::vector::Vec2,
helpers::{matrix::Mat2, pixel::Pixel},
};
use anyhow::bail;
#[derive(Clone, Debug, PartialEq)]
pub enum Block {
Literal(Vec<Pixel>),
CompressedLiteral(Vec<u8>),
Split(Box<[Block; 2]>),
Reference { translation: Vec2<isize> },
AdvancedReference(AdvancedReference),
}
#[derive(Clone, Debug, PartialEq)]
pub struct AdvancedReference {
pub translation: Vec2<i8>,
pub transform: Mat2<i8>,
pub value_scale: i8,
}
impl Block {
pub const REFZERO: Block = Block::Reference {
translation: Vec2::<isize>::ZERO,
};
pub fn write(&self, sink: &mut impl std::io::Write, size: Vec2<isize>) -> anyhow::Result<()> {
match &self {
Block::Literal(pixels) => {
sink.put(0u8)?;
pixels.write_const_size(sink, size.area() as usize)?;
}
Block::CompressedLiteral(data) => {
sink.put(1u8)?;
data.write(sink)?;
}
Block::Split(box [a, b]) => {
sink.put(2u8)?;
let [asize, bsize] = split_size(size);
a.write(sink, asize)?;
b.write(sink, bsize)?;
}
Block::Reference { translation } => {
sink.put(3u8)?;
sink.put(Small(*translation))?;
}
Block::AdvancedReference(AdvancedReference {
translation,
transform,
value_scale,
}) => {
sink.put(4u8)?;
sink.put((*translation, *transform, *value_scale))?;
}
}
Ok(())
}
pub fn read(source: &mut impl std::io::Read, size: Vec2<isize>) -> anyhow::Result<Self> {
let variant = source.get::<u8>()?;
Ok(match variant {
0 => Block::Literal(Vec::read_const_size(source, size.area() as usize)?),
1 => Block::CompressedLiteral(Vec::read(source)?),
2 => Block::Split(Box::new({
let [asize, bsize] = split_size(size);
let a = Block::read(source, asize)?;
let b = Block::read(source, bsize)?;
[a, b]
})),
3 => Block::Reference {
translation: source.get::<Small<Vec2<isize>>>()?.0,
},
4 => Block::AdvancedReference(AdvancedReference {
translation: source.get()?,
transform: source.get()?,
value_scale: source.get()?,
}),
x => bail!("corrupt block type ({})", x),
})
}
}
pub fn split_size(size: Vec2<isize>) -> [Vec2<isize>; 2] {
let vert = size.x > size.y;
[
if vert {
(size.x / 2, size.y).into()
} else {
(size.x, size.y / 2).into()
},
if vert {
(size.x - size.x / 2, size.y).into()
} else {
(size.x, size.y - size.y / 2).into()
},
]
}
impl Block {
pub fn is_literal(&self) -> bool {
matches!(self, Block::Literal(..))
}
pub fn identical_ref(a: &Self, b: &Self) -> bool {
matches!(a, Block::Reference { .. }) && a == b
}
}
impl Default for AdvancedReference {
fn default() -> Self {
Self {
translation: Vec2 { x: 0, y: 0 },
transform: Mat2 {
a: 4,
b: 0,
c: 0,
d: 4,
},
value_scale: 0,
}
}
}
|
