1use crate::{Image, ImageFormat, InvalidNineSlice, NineSlice};
2use std::{
3 fmt,
4 rc::Rc,
5 sync::{
6 Arc,
7 atomic::{AtomicU64, Ordering},
8 },
9};
10
11#[derive(Clone, Debug)]
13pub enum ImageAsset {
14 Embedded(Image),
15 Loaded(LoadedImage),
16 Animated(Rc<LoadedAnimation>),
17}
18
19impl PartialEq for ImageAsset {
20 fn eq(&self, other: &Self) -> bool {
21 match (self, other) {
22 (Self::Embedded(left), Self::Embedded(right)) => left == right,
23 (Self::Loaded(left), Self::Loaded(right)) => left == right,
24 (Self::Animated(left), Self::Animated(right)) => {
25 Rc::ptr_eq(left, right) || left == right
26 }
27 (Self::Embedded(Image::Animated(embedded)), Self::Animated(loaded))
28 | (Self::Animated(loaded), Self::Embedded(Image::Animated(embedded))) => {
29 embedded.matches_loaded(loaded)
30 }
31 (Self::Loaded(_), Self::Embedded(_)) | (Self::Embedded(_), Self::Loaded(_)) => {
32 let (Some(left), Some(right)) = (self.pixels(), other.pixels()) else {
33 return false;
34 };
35 left.format == right.format
36 && left.size == right.size
37 && left.edges == right.edges
38 && left.bytes == right.bytes
39 }
40 _ => false,
41 }
42 }
43}
44
45impl Eq for ImageAsset {}
46
47impl Default for ImageAsset {
48 fn default() -> Self {
49 Self::Embedded(Image::Empty)
50 }
51}
52
53impl From<Image> for ImageAsset {
54 fn from(image: Image) -> Self {
55 Self::Embedded(image)
56 }
57}
58
59#[derive(Clone)]
60pub struct LoadedImage {
61 source: Arc<LoadedImageSource>,
62 edges: Option<NineSlice>,
63}
64
65struct LoadedImageSource {
66 id: u64,
67 format: ImageFormat,
68 bytes: Vec<u8>,
69 size: [u32; 2],
70}
71
72impl LoadedImage {
73 pub fn new(format: ImageFormat, bytes: Vec<u8>, size: [u32; 2]) -> Self {
74 static NEXT_IMAGE: AtomicU64 = AtomicU64::new(1);
75 let id = NEXT_IMAGE
76 .try_update(Ordering::Relaxed, Ordering::Relaxed, |id| id.checked_add(1))
77 .expect("loaded image identity exhausted");
78 Self {
79 source: Arc::new(LoadedImageSource {
80 id,
81 format,
82 bytes,
83 size,
84 }),
85 edges: None,
86 }
87 }
88
89 pub(crate) fn bytes(&self) -> &[u8] {
90 &self.source.bytes
91 }
92}
93
94impl PartialEq for LoadedImage {
95 fn eq(&self, other: &Self) -> bool {
96 self.edges == other.edges
97 && (Arc::ptr_eq(&self.source, &other.source)
98 || (self.source.size == other.source.size
99 && self.source.format == other.source.format
100 && self.source.bytes == other.source.bytes))
101 }
102}
103
104impl Eq for LoadedImage {}
105
106impl fmt::Debug for LoadedImage {
107 fn fmt(&self, output: &mut fmt::Formatter<'_>) -> fmt::Result {
108 output
109 .debug_struct("LoadedImage")
110 .field("format", &self.source.format)
111 .field("size", &self.source.size)
112 .field("edges", &self.edges)
113 .finish()
114 }
115}
116
117#[derive(Debug, PartialEq, Eq)]
118pub struct LoadedAnimation {
119 pub(crate) size: [u32; 2],
120 pub(crate) frames: Vec<(u32, LoadedImage)>,
121 pub(crate) plays: u32,
122}
123
124impl LoadedAnimation {
125 pub fn new(size: [u32; 2], frames: Vec<(u32, Vec<u8>)>, plays: u32) -> Self {
126 Self {
127 size,
128 frames: frames
129 .into_iter()
130 .map(|(end, bytes)| (end, LoadedImage::new(ImageFormat::Png, bytes, size)))
131 .collect(),
132 plays,
133 }
134 }
135}
136
137#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
140pub enum ImageIdentity {
141 Embedded(usize),
142 Loaded(u64),
143}
144
145pub struct ImagePixels<'a> {
146 pub identity: ImageIdentity,
147 pub format: ImageFormat,
148 pub bytes: &'a [u8],
149 pub size: [u32; 2],
150 pub edges: Option<NineSlice>,
151}
152
153impl ImageAsset {
154 pub fn size(&self) -> [u32; 2] {
155 match self {
156 Self::Embedded(image) => image.size(),
157 Self::Loaded(image) => image.source.size,
158 Self::Animated(animation) => animation.size,
159 }
160 }
161
162 pub fn frame_count(&self) -> usize {
163 match self {
164 Self::Embedded(image) => image.frame_count(),
165 Self::Loaded(_) => 1,
166 Self::Animated(animation) => animation.frames.len(),
167 }
168 }
169
170 pub fn frame(&self, index: usize) -> Self {
171 match self {
172 Self::Embedded(image) => image.frame(index).into(),
173 Self::Loaded(_) => self.clone(),
174 Self::Animated(animation) => animation
175 .frames
176 .get(index)
177 .or_else(|| animation.frames.first())
178 .map_or_else(Self::default, |(_, image)| Self::Loaded(image.clone())),
179 }
180 }
181
182 pub fn with_nine_slice(self, edges: NineSlice) -> Result<Self, InvalidNineSlice> {
183 match self {
184 Self::Embedded(image) => image.with_nine_slice(edges).map(Self::Embedded),
185 Self::Loaded(mut image) if edges.fits(image.source.size) => {
186 image.edges = Some(edges);
187 Ok(Self::Loaded(image))
188 }
189 _ => Err(InvalidNineSlice),
190 }
191 }
192
193 pub fn pixels(&self) -> Option<ImagePixels<'_>> {
194 let (identity, format, bytes, size, edges) = match self {
195 Self::Embedded(Image::Embedded {
196 format,
197 bytes,
198 size,
199 }) => (
200 ImageIdentity::Embedded(bytes.as_ptr() as usize),
201 *format,
202 *bytes,
203 *size,
204 None,
205 ),
206 Self::Embedded(Image::NineSliced {
207 format,
208 bytes,
209 size,
210 edges,
211 }) => (
212 ImageIdentity::Embedded(bytes.as_ptr() as usize),
213 *format,
214 *bytes,
215 *size,
216 Some(*edges),
217 ),
218 Self::Loaded(image) => (
219 ImageIdentity::Loaded(image.source.id),
220 image.source.format,
221 image.bytes(),
222 image.source.size,
223 image.edges,
224 ),
225 _ => return None,
226 };
227 Some(ImagePixels {
228 identity,
229 format,
230 bytes,
231 size,
232 edges,
233 })
234 }
235}