Skip to main content

xrack_runtime/
image_asset.rs

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/// The image value accepted by layout, rendering, and playback.
12#[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/// Identity for a cache entry. Loaded assets can outlive their original scene
138/// without making a later allocation at the same address hit an old texture.
139#[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}