use crate::{DevicePixels, Pixels, Result, SharedString, Size, size};
use smallvec::SmallVec;
use image::{Delay, Frame};
use std::{
borrow::Cow,
fmt,
hash::Hash,
sync::atomic::{AtomicUsize, Ordering::SeqCst},
};
pub trait AssetSource: 'static + Send + Sync {
fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>>;
fn list(&self, path: &str) -> Result<Vec<SharedString>>;
}
impl AssetSource for () {
fn load(&self, _path: &str) -> Result<Option<Cow<'static, [u8]>>> {
Ok(None)
}
fn list(&self, _path: &str) -> Result<Vec<SharedString>> {
Ok(vec![])
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ImageId(pub usize);
#[derive(PartialEq, Eq, Hash, Clone)]
#[expect(missing_docs)]
pub struct RenderImageParams {
pub image_id: ImageId,
pub frame_index: usize,
}
pub struct RenderImage {
pub id: ImageId,
pub(crate) scale_factor: f32,
data: SmallVec<[Frame; 1]>,
dynamic: bool,
gpu_size: Option<Size<DevicePixels>>,
natural: Option<Size<DevicePixels>>,
}
impl PartialEq for RenderImage {
fn eq(&self, other: &Self) -> bool {
self.id == other.id
}
}
impl Eq for RenderImage {}
impl RenderImage {
pub fn new(data: impl Into<SmallVec<[Frame; 1]>>) -> Self {
static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
Self {
id: ImageId(NEXT_ID.fetch_add(1, SeqCst)),
scale_factor: 1.0,
data: data.into(),
dynamic: false,
gpu_size: None,
natural: None,
}
}
pub fn from_gpu(size: Size<DevicePixels>) -> Self {
let mut image = Self::new(SmallVec::new());
image.gpu_size = Some(size);
image.dynamic = true;
image
}
pub fn with_natural_size(mut self, natural: Size<DevicePixels>) -> Self {
self.natural = Some(natural);
self
}
pub fn natural_size(&self, frame_index: usize) -> Size<DevicePixels> {
self.natural.unwrap_or_else(|| self.size(frame_index))
}
pub fn is_reduced(&self) -> bool {
self.natural.is_some()
}
pub fn dynamic(mut self) -> Self {
self.dynamic = true;
self
}
pub fn is_dynamic(&self) -> bool {
self.dynamic
}
pub fn successor(&self, data: impl Into<SmallVec<[Frame; 1]>>) -> Self {
Self {
id: self.id,
scale_factor: self.scale_factor,
data: data.into(),
dynamic: self.dynamic,
gpu_size: None,
natural: None,
}
}
pub fn as_bytes(&self, frame_index: usize) -> Option<&[u8]> {
self.data
.get(frame_index)
.map(|frame| frame.buffer().as_raw().as_slice())
}
pub fn size(&self, frame_index: usize) -> Size<DevicePixels> {
if frame_index == 0 { if let Some(size) = self.gpu_size { return size; } }
self.data
.get(frame_index)
.map(|frame| {
let (width, height) = frame.buffer().dimensions();
size(width.into(), height.into())
})
.unwrap_or_default()
}
pub(crate) fn render_size(&self, frame_index: usize) -> Size<Pixels> {
self.natural_size(frame_index)
.map(|v| (v.0 as f32 / self.scale_factor).into())
}
pub fn delay(&self, frame_index: usize) -> Delay {
self.data
.get(frame_index)
.map(|frame| frame.delay())
.unwrap_or(Delay::from_numer_denom_ms(100, 1))
}
pub fn frame_count(&self) -> usize {
if self.gpu_size.is_some() { return 1; }
self.data.len()
}
}
impl fmt::Debug for RenderImage {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ImageData")
.field("id", &self.id)
.field("size", &self.data.first().map(|f| f.buffer().dimensions()))
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
use smallvec::SmallVec;
#[test]
fn gpu_image_keeps_intrinsics_without_a_cpu_placeholder() {
let dimensions=size(DevicePixels(16384),DevicePixels(16384));
let gpu=RenderImage::from_gpu(dimensions);
assert_eq!(gpu.size(0),dimensions);
assert_eq!(gpu.natural_size(0),dimensions);
assert_eq!(gpu.frame_count(),1);
assert_eq!(gpu.as_bytes(0),None);
assert_eq!(gpu.size(1),Size::default());
assert!(gpu.is_dynamic());
}
#[test]
fn empty_render_image_does_not_panic() {
let image = RenderImage::new(SmallVec::new());
assert_eq!(image.frame_count(), 0);
assert_eq!(image.size(0), Size::default());
assert_eq!(image.as_bytes(0), None);
assert_eq!(image.render_size(0), Size::default());
assert_eq!(image.delay(0), Delay::from_numer_denom_ms(100, 1));
let _ = format!("{image:?}");
}
#[test]
fn a_frame_of_a_moving_picture_is_marked_dynamic() {
let still = RenderImage::new(SmallVec::new());
assert!(!still.is_dynamic());
let frame = RenderImage::new(SmallVec::new()).dynamic();
assert!(frame.is_dynamic());
assert_ne!(still.id, frame.id);
}
#[test]
fn a_reduced_copy_lays_out_at_the_natural_size() {
let pixels = image::RgbaImage::new(4, 2);
let copy = RenderImage::new(SmallVec::from_const([Frame::new(pixels)]))
.with_natural_size(size(DevicePixels(400), DevicePixels(200)));
assert!(copy.is_reduced());
assert_eq!(copy.size(0), size(DevicePixels(4), DevicePixels(2)));
assert_eq!(copy.natural_size(0), size(DevicePixels(400), DevicePixels(200)));
assert_eq!(copy.render_size(0), size(Pixels::from(400.), Pixels::from(200.)));
let full = RenderImage::new(SmallVec::from_const([Frame::new(image::RgbaImage::new(3, 3))]));
assert!(!full.is_reduced());
assert_eq!(full.natural_size(0), full.size(0));
}
}