me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Remove image abstractions in iced_graphics

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2023-03-07 03:47:49 +01:00
parent 9b4bcd287a
commit 3a26baa564
No known key found for this signature in database
GPG key ID: 140CC052C94F138E
11 changed files with 352 additions and 436 deletions
Download patch file Download diff file Expand all files Collapse all files

23
graphics/Cargo.toml
View file

@ -11,22 +11,9 @@ keywords = ["gui", "ui", "graphics", "interface", "widgets"]
categories = ["gui"]
[features]
svg = ["resvg"]
image = ["png", "jpeg", "jpeg_rayon", "gif", "webp", "bmp"]
png = ["image_rs/png"]
jpeg = ["image_rs/jpeg"]
jpeg_rayon = ["image_rs/jpeg_rayon"]
gif = ["image_rs/gif"]
webp = ["image_rs/webp"]
pnm = ["image_rs/pnm"]
ico = ["image_rs/ico"]
bmp = ["image_rs/bmp"]
hdr = ["image_rs/hdr"]
dds = ["image_rs/dds"]
farbfeld = ["image_rs/farbfeld"]
geometry = ["lyon_path"]
opengl = []
image_rs = ["kamadak-exif"]
image = ["dep:image", "kamadak-exif"]
[dependencies]
glam = "0.21.3"
@ -47,14 +34,8 @@ path = "../core"
version = "0.8"
optional = true
[dependencies.image_rs]
[dependencies.image]
version = "0.24"
package = "image"
default-features = false
optional = true
[dependencies.resvg]
version = "0.29"
optional = true
[dependencies.kamadak-exif]

98
graphics/src/image.rs
View file

@ -1,10 +1,94 @@
//! Render images.
#[cfg(feature = "image_rs")]
pub mod raster;
//! Load and operate on images.
use crate::core::image::{Data, Handle};
#[cfg(feature = "svg")]
pub mod vector;
use bitflags::bitflags;
pub mod storage;
pub use ::image as image_rs;
pub use storage::Storage;
pub fn load(handle: &Handle) -> image_rs::ImageResult<image_rs::DynamicImage> {
match handle.data() {
Data::Path(path) => {
let image = ::image::open(path)?;
let operation = std::fs::File::open(path)
.ok()
.map(std::io::BufReader::new)
.and_then(|mut reader| Operation::from_exif(&mut reader).ok())
.unwrap_or_else(Operation::empty);
Ok(operation.perform(image))
}
Data::Bytes(bytes) => {
let image = ::image::load_from_memory(bytes)?;
let operation =
Operation::from_exif(&mut std::io::Cursor::new(bytes))
.ok()
.unwrap_or_else(Operation::empty);
Ok(operation.perform(image))
}
Data::Rgba {
width,
height,
pixels,
} => {
if let Some(image) = image_rs::ImageBuffer::from_vec(
*width,
*height,
pixels.to_vec(),
) {
Ok(image_rs::DynamicImage::ImageRgba8(image))
} else {
Err(image_rs::error::ImageError::Limits(
image_rs::error::LimitError::from_kind(
image_rs::error::LimitErrorKind::DimensionError,
),
))
}
}
}
}
bitflags! {
struct Operation: u8 {
const FLIP_HORIZONTALLY = 0b001;
const ROTATE_180 = 0b010;
const FLIP_DIAGONALLY = 0b100;
}
}
impl Operation {
// Meaning of the returned value is described e.g. at:
// https://magnushoff.com/articles/jpeg-orientation/
fn from_exif<R>(reader: &mut R) -> Result<Self, exif::Error>
where
R: std::io::BufRead + std::io::Seek,
{
let exif = exif::Reader::new().read_from_container(reader)?;
Ok(exif
.get_field(exif::Tag::Orientation, exif::In::PRIMARY)
.and_then(|field| field.value.get_uint(0))
.and_then(|value| u8::try_from(value).ok())
.and_then(|value| Self::from_bits(value.saturating_sub(1)))
.unwrap_or_else(Self::empty))
}
fn perform(self, mut image: image::DynamicImage) -> image::DynamicImage {
use image::imageops;
if self.contains(Self::FLIP_DIAGONALLY) {
imageops::flip_vertical_in_place(&mut image)
}
if self.contains(Self::ROTATE_180) {
imageops::rotate180_in_place(&mut image);
}
if self.contains(Self::FLIP_HORIZONTALLY) {
imageops::flip_horizontal_in_place(&mut image);
}
image
}
}

242
graphics/src/image/raster.rs
View file

@ -1,242 +0,0 @@
//! Raster image loading and caching.
use crate::image::Storage;
use iced_core::image;
use iced_core::Size;
use bitflags::bitflags;
use std::collections::{HashMap, HashSet};
/// Entry in cache corresponding to an image handle
#[derive(Debug)]
pub enum Memory<T: Storage> {
/// Image data on host
Host(::image_rs::ImageBuffer<::image_rs::Rgba<u8>, Vec<u8>>),
/// Storage entry
Device(T::Entry),
/// Image not found
NotFound,
/// Invalid image data
Invalid,
}
impl<T: Storage> Memory<T> {
/// Width and height of image
pub fn dimensions(&self) -> Size<u32> {
use crate::image::storage::Entry;
match self {
Memory::Host(image) => {
let (width, height) = image.dimensions();
Size::new(width, height)
}
Memory::Device(entry) => entry.size(),
Memory::NotFound => Size::new(1, 1),
Memory::Invalid => Size::new(1, 1),
}
}
}
/// Caches image raster data
#[derive(Debug)]
pub struct Cache<T: Storage> {
map: HashMap<u64, Memory<T>>,
hits: HashSet<u64>,
}
impl<T: Storage> Cache<T> {
/// Load image
pub fn load(&mut self, handle: &image::Handle) -> &mut Memory<T> {
if self.contains(handle) {
return self.get(handle).unwrap();
}
let memory = match handle.data() {
image::Data::Path(path) => {
if let Ok(image) = image_rs::open(path) {
let operation = std::fs::File::open(path)
.ok()
.map(std::io::BufReader::new)
.and_then(|mut reader| {
Operation::from_exif(&mut reader).ok()
})
.unwrap_or_else(Operation::empty);
Memory::Host(operation.perform(image.to_rgba8()))
} else {
Memory::NotFound
}
}
image::Data::Bytes(bytes) => {
if let Ok(image) = image_rs::load_from_memory(bytes) {
let operation =
Operation::from_exif(&mut std::io::Cursor::new(bytes))
.ok()
.unwrap_or_else(Operation::empty);
Memory::Host(operation.perform(image.to_rgba8()))
} else {
Memory::Invalid
}
}
image::Data::Rgba {
width,
height,
pixels,
} => {
if let Some(image) = image_rs::ImageBuffer::from_vec(
*width,
*height,
pixels.to_vec(),
) {
Memory::Host(image)
} else {
Memory::Invalid
}
}
};
self.insert(handle, memory);
self.get(handle).unwrap()
}
/// Load image and upload raster data
pub fn upload(
&mut self,
handle: &image::Handle,
state: &mut T::State<'_>,
storage: &mut T,
) -> Option<&T::Entry> {
let memory = self.load(handle);
if let Memory::Host(image) = memory {
let (width, height) = image.dimensions();
let entry = storage.upload(width, height, image, state)?;
*memory = Memory::Device(entry);
}
if let Memory::Device(allocation) = memory {
Some(allocation)
} else {
None
}
}
/// Trim cache misses from cache
pub fn trim(&mut self, storage: &mut T, state: &mut T::State<'_>) {
let hits = &self.hits;
self.map.retain(|k, memory| {
let retain = hits.contains(k);
if !retain {
if let Memory::Device(entry) = memory {
storage.remove(entry, state);
}
}
retain
});
self.hits.clear();
}
fn get(&mut self, handle: &image::Handle) -> Option<&mut Memory<T>> {
let _ = self.hits.insert(handle.id());
self.map.get_mut(&handle.id())
}
fn insert(&mut self, handle: &image::Handle, memory: Memory<T>) {
let _ = self.map.insert(handle.id(), memory);
}
fn contains(&self, handle: &image::Handle) -> bool {
self.map.contains_key(&handle.id())
}
}
impl<T: Storage> Default for Cache<T> {
fn default() -> Self {
Self {
map: HashMap::new(),
hits: HashSet::new(),
}
}
}
bitflags! {
struct Operation: u8 {
const FLIP_HORIZONTALLY = 0b001;
const ROTATE_180 = 0b010;
const FLIP_DIAGONALLY = 0b100;
}
}
impl Operation {
// Meaning of the returned value is described e.g. at:
// https://magnushoff.com/articles/jpeg-orientation/
fn from_exif<R>(reader: &mut R) -> Result<Self, exif::Error>
where
R: std::io::BufRead + std::io::Seek,
{
let exif = exif::Reader::new().read_from_container(reader)?;
Ok(exif
.get_field(exif::Tag::Orientation, exif::In::PRIMARY)
.and_then(|field| field.value.get_uint(0))
.and_then(|value| u8::try_from(value).ok())
.and_then(|value| Self::from_bits(value.saturating_sub(1)))
.unwrap_or_else(Self::empty))
}
fn perform<P>(
self,
image: image_rs::ImageBuffer<P, Vec<P::Subpixel>>,
) -> image_rs::ImageBuffer<P, Vec<P::Subpixel>>
where
P: image_rs::Pixel + 'static,
{
use image_rs::imageops;
let mut image = if self.contains(Self::FLIP_DIAGONALLY) {
flip_diagonally(image)
} else {
image
};
if self.contains(Self::ROTATE_180) {
imageops::rotate180_in_place(&mut image);
}
if self.contains(Self::FLIP_HORIZONTALLY) {
imageops::flip_horizontal_in_place(&mut image);
}
image
}
}
fn flip_diagonally<I>(
image: I,
) -> image_rs::ImageBuffer<I::Pixel, Vec<<I::Pixel as image_rs::Pixel>::Subpixel>>
where
I: image_rs::GenericImage,
I::Pixel: 'static,
{
let (width, height) = image.dimensions();
let mut out = image_rs::ImageBuffer::new(height, width);
for x in 0..width {
for y in 0..height {
let p = image.get_pixel(x, y);
out.put_pixel(y, x, p);
}
}
out
}

4
graphics/src/lib.rs
View file

@ -28,13 +28,15 @@ mod viewport;
pub mod backend;
pub mod compositor;
pub mod image;
pub mod primitive;
pub mod renderer;
#[cfg(feature = "geometry")]
pub mod geometry;
#[cfg(feature = "image")]
pub mod image;
pub use antialiasing::Antialiasing;
pub use backend::Backend;
pub use compositor::Compositor;

20
wgpu/Cargo.toml
View file

@ -8,21 +8,9 @@ license = "MIT AND OFL-1.1"
repository = "https://github.com/iced-rs/iced"
[features]
svg = ["iced_graphics/svg"]
image = ["iced_graphics/image"]
png = ["iced_graphics/png"]
jpeg = ["iced_graphics/jpeg"]
jpeg_rayon = ["iced_graphics/jpeg_rayon"]
gif = ["iced_graphics/gif"]
webp = ["iced_graphics/webp"]
pnm = ["iced_graphics/pnm"]
ico = ["iced_graphics/ico"]
bmp = ["iced_graphics/bmp"]
hdr = ["iced_graphics/hdr"]
dds = ["iced_graphics/dds"]
farbfeld = ["iced_graphics/farbfeld"]
geometry = ["iced_graphics/geometry", "lyon"]
spirv = ["wgpu/spirv"]
image = ["iced_graphics/image"]
svg = ["resvg"]
[dependencies]
wgpu = "0.14"
@ -70,6 +58,10 @@ version = "0.21.3"
version = "1.0"
optional = true
[dependencies.resvg]
version = "0.29"
optional = true
[dependencies.tracing]
version = "0.1.6"
optional = true

2
wgpu/src/backend.rs
View file

@ -119,7 +119,7 @@ impl Backend {
self.triangle_pipeline.end_frame();
#[cfg(any(feature = "image", feature = "svg"))]
self.image_pipeline.end_frame(device, queue, encoder);
self.image_pipeline.end_frame();
}
fn prepare_text(

39
wgpu/src/image.rs
View file

@ -1,5 +1,11 @@
mod atlas;
#[cfg(feature = "image")]
mod raster;
#[cfg(feature = "svg")]
mod vector;
use atlas::Atlas;
use crate::core::{Rectangle, Size};
@ -7,12 +13,6 @@ use crate::graphics::Transformation;
use crate::layer;
use crate::Buffer;
#[cfg(feature = "image")]
use crate::graphics::image::raster;
#[cfg(feature = "svg")]
use crate::graphics::image::vector;
use std::cell::RefCell;
use std::mem;
@ -30,9 +30,9 @@ use tracing::info_span;
#[derive(Debug)]
pub struct Pipeline {
#[cfg(feature = "image")]
raster_cache: RefCell<raster::Cache<Atlas>>,
raster_cache: RefCell<raster::Cache>,
#[cfg(feature = "svg")]
vector_cache: RefCell<vector::Cache<Atlas>>,
vector_cache: RefCell<vector::Cache>,
pipeline: wgpu::RenderPipeline,
vertices: wgpu::Buffer,
@ -368,8 +368,10 @@ impl Pipeline {
#[cfg(feature = "image")]
layer::Image::Raster { handle, bounds } => {
if let Some(atlas_entry) = raster_cache.upload(
device,
queue,
encoder,
handle,
&mut (device, queue, encoder),
&mut self.texture_atlas,
) {
add_instances(
@ -392,11 +394,13 @@ impl Pipeline {
let size = [bounds.width, bounds.height];
if let Some(atlas_entry) = vector_cache.upload(
device,
queue,
encoder,
handle,
*color,
size,
_scale,
&mut (device, queue, encoder),
&mut self.texture_atlas,
) {
add_instances(
@ -477,21 +481,12 @@ impl Pipeline {
}
}
pub fn end_frame(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
) {
pub fn end_frame(&mut self) {
#[cfg(feature = "image")]
self.raster_cache
.borrow_mut()
.trim(&mut self.texture_atlas, &mut (device, queue, encoder));
self.raster_cache.borrow_mut().trim(&mut self.texture_atlas);
#[cfg(feature = "svg")]
self.vector_cache
.borrow_mut()
.trim(&mut self.texture_atlas, &mut (device, queue, encoder));
self.vector_cache.borrow_mut().trim(&mut self.texture_atlas);
self.prepare_layer = 0;
}

190
wgpu/src/image/atlas.rs
View file

@ -13,7 +13,6 @@ use allocator::Allocator;
pub const SIZE: u32 = 2048;
use crate::core::Size;
use crate::graphics::image;
use std::num::NonZeroU32;
@ -64,6 +63,97 @@ impl Atlas {
self.layers.len()
}
pub fn upload(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
width: u32,
height: u32,
data: &[u8],
) -> Option<Entry> {
let entry = {
let current_size = self.layers.len();
let entry = self.allocate(width, height)?;
// We grow the internal texture after allocating if necessary
let new_layers = self.layers.len() - current_size;
self.grow(new_layers, device, encoder);
entry
};
log::info!("Allocated atlas entry: {:?}", entry);
// It is a webgpu requirement that:
// BufferCopyView.layout.bytes_per_row % wgpu::COPY_BYTES_PER_ROW_ALIGNMENT == 0
// So we calculate padded_width by rounding width up to the next
// multiple of wgpu::COPY_BYTES_PER_ROW_ALIGNMENT.
let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
let padding = (align - (4 * width) % align) % align;
let padded_width = (4 * width + padding) as usize;
let padded_data_size = padded_width * height as usize;
let mut padded_data = vec![0; padded_data_size];
for row in 0..height as usize {
let offset = row * padded_width;
padded_data[offset..offset + 4 * width as usize].copy_from_slice(
&data[row * 4 * width as usize..(row + 1) * 4 * width as usize],
)
}
match &entry {
Entry::Contiguous(allocation) => {
self.upload_allocation(
&padded_data,
width,
height,
padding,
0,
allocation,
queue,
);
}
Entry::Fragmented { fragments, .. } => {
for fragment in fragments {
let (x, y) = fragment.position;
let offset = (y * padded_width as u32 + 4 * x) as usize;
self.upload_allocation(
&padded_data,
width,
height,
padding,
offset,
&fragment.allocation,
queue,
);
}
}
}
log::info!("Current atlas: {:?}", self);
Some(entry)
}
pub fn remove(&mut self, entry: &Entry) {
log::info!("Removing atlas entry: {:?}", entry);
match entry {
Entry::Contiguous(allocation) => {
self.deallocate(allocation);
}
Entry::Fragmented { fragments, .. } => {
for fragment in fragments {
self.deallocate(&fragment.allocation);
}
}
}
}
fn allocate(&mut self, width: u32, height: u32) -> Option<Entry> {
// Allocate one layer if texture fits perfectly
if width == SIZE && height == SIZE {
@ -296,101 +386,3 @@ impl Atlas {
});
}
}
impl image::Storage for Atlas {
type Entry = Entry;
type State<'a> = (
&'a wgpu::Device,
&'a wgpu::Queue,
&'a mut wgpu::CommandEncoder,
);
fn upload(
&mut self,
width: u32,
height: u32,
data: &[u8],
(device, queue, encoder): &mut Self::State<'_>,
) -> Option<Self::Entry> {
let entry = {
let current_size = self.layers.len();
let entry = self.allocate(width, height)?;
// We grow the internal texture after allocating if necessary
let new_layers = self.layers.len() - current_size;
self.grow(new_layers, device, encoder);
entry
};
log::info!("Allocated atlas entry: {:?}", entry);
// It is a webgpu requirement that:
// BufferCopyView.layout.bytes_per_row % wgpu::COPY_BYTES_PER_ROW_ALIGNMENT == 0
// So we calculate padded_width by rounding width up to the next
// multiple of wgpu::COPY_BYTES_PER_ROW_ALIGNMENT.
let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
let padding = (align - (4 * width) % align) % align;
let padded_width = (4 * width + padding) as usize;
let padded_data_size = padded_width * height as usize;
let mut padded_data = vec![0; padded_data_size];
for row in 0..height as usize {
let offset = row * padded_width;
padded_data[offset..offset + 4 * width as usize].copy_from_slice(
&data[row * 4 * width as usize..(row + 1) * 4 * width as usize],
)
}
match &entry {
Entry::Contiguous(allocation) => {
self.upload_allocation(
&padded_data,
width,
height,
padding,
0,
allocation,
queue,
);
}
Entry::Fragmented { fragments, .. } => {
for fragment in fragments {
let (x, y) = fragment.position;
let offset = (y * padded_width as u32 + 4 * x) as usize;
self.upload_allocation(
&padded_data,
width,
height,
padding,
offset,
&fragment.allocation,
queue,
);
}
}
}
log::info!("Current atlas: {:?}", self);
Some(entry)
}
fn remove(&mut self, entry: &Entry, _: &mut Self::State<'_>) {
log::info!("Removing atlas entry: {:?}", entry);
match entry {
Entry::Contiguous(allocation) => {
self.deallocate(allocation);
}
Entry::Fragmented { fragments, .. } => {
for fragment in fragments {
self.deallocate(&fragment.allocation);
}
}
}
}
}

6
wgpu/src/image/atlas/entry.rs
View file

@ -1,5 +1,4 @@
use crate::core::Size;
use crate::graphics::image;
use crate::image::atlas;
#[derive(Debug)]
@ -11,8 +10,9 @@ pub enum Entry {
},
}
impl image::storage::Entry for Entry {
fn size(&self) -> Size<u32> {
impl Entry {
#[cfg(feature = "image")]
pub fn size(&self) -> Size<u32> {
match self {
Entry::Contiguous(allocation) => allocation.size(),
Entry::Fragmented { size, .. } => *size,

121
wgpu/src/image/raster.rs Normal file
View file

@ -0,0 +1,121 @@
use crate::core::image;
use crate::core::Size;
use crate::graphics;
use crate::graphics::image::image_rs;
use crate::image::atlas::{self, Atlas};
use std::collections::{HashMap, HashSet};
/// Entry in cache corresponding to an image handle
#[derive(Debug)]
pub enum Memory {
/// Image data on host
Host(image_rs::ImageBuffer<image_rs::Rgba<u8>, Vec<u8>>),
/// Storage entry
Device(atlas::Entry),
/// Image not found
NotFound,
/// Invalid image data
Invalid,
}
impl Memory {
/// Width and height of image
pub fn dimensions(&self) -> Size<u32> {
match self {
Memory::Host(image) => {
let (width, height) = image.dimensions();
Size::new(width, height)
}
Memory::Device(entry) => entry.size(),
Memory::NotFound => Size::new(1, 1),
Memory::Invalid => Size::new(1, 1),
}
}
}
/// Caches image raster data
#[derive(Debug, Default)]
pub struct Cache {
map: HashMap<u64, Memory>,
hits: HashSet<u64>,
}
impl Cache {
/// Load image
pub fn load(&mut self, handle: &image::Handle) -> &mut Memory {
if self.contains(handle) {
return self.get(handle).unwrap();
}
let memory = match graphics::image::load(handle) {
Ok(image) => Memory::Host(image.to_rgba8()),
Err(image_rs::error::ImageError::IoError(_)) => Memory::NotFound,
Err(_) => Memory::Invalid,
};
self.insert(handle, memory);
self.get(handle).unwrap()
}
/// Load image and upload raster data
pub fn upload(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
handle: &image::Handle,
atlas: &mut Atlas,
) -> Option<&atlas::Entry> {
let memory = self.load(handle);
if let Memory::Host(image) = memory {
let (width, height) = image.dimensions();
let entry =
atlas.upload(device, queue, encoder, width, height, image)?;
*memory = Memory::Device(entry);
}
if let Memory::Device(allocation) = memory {
Some(allocation)
} else {
None
}
}
/// Trim cache misses from cache
pub fn trim(&mut self, atlas: &mut Atlas) {
let hits = &self.hits;
self.map.retain(|k, memory| {
let retain = hits.contains(k);
if !retain {
if let Memory::Device(entry) = memory {
atlas.remove(entry);
}
}
retain
});
self.hits.clear();
}
fn get(&mut self, handle: &image::Handle) -> Option<&mut Memory> {
let _ = self.hits.insert(handle.id());
self.map.get_mut(&handle.id())
}
fn insert(&mut self, handle: &image::Handle, memory: Memory) {
let _ = self.map.insert(handle.id(), memory);
}
fn contains(&self, handle: &image::Handle) -> bool {
self.map.contains_key(&handle.id())
}
}

43
graphics/src/image/vector.rs → wgpu/src/image/vector.rs
View file

@ -1,8 +1,6 @@
//! Vector image loading and caching
use crate::image::Storage;
use iced_core::svg;
use iced_core::{Color, Size};
use crate::core::svg;
use crate::core::{Color, Size};
use crate::image::atlas::{self, Atlas};
use resvg::tiny_skia;
use resvg::usvg;
@ -32,17 +30,17 @@ impl Svg {
}
/// Caches svg vector and raster data
#[derive(Debug)]
pub struct Cache<T: Storage> {
#[derive(Debug, Default)]
pub struct Cache {
svgs: HashMap<u64, Svg>,
rasterized: HashMap<(u64, u32, u32, ColorFilter), T::Entry>,
rasterized: HashMap<(u64, u32, u32, ColorFilter), atlas::Entry>,
svg_hits: HashSet<u64>,
rasterized_hits: HashSet<(u64, u32, u32, ColorFilter)>,
}
type ColorFilter = Option<[u8; 4]>;
impl<T: Storage> Cache<T> {
impl Cache {
/// Load svg
pub fn load(&mut self, handle: &svg::Handle) -> &Svg {
if self.svgs.contains_key(&handle.id()) {
@ -73,13 +71,15 @@ impl<T: Storage> Cache<T> {
/// Load svg and upload raster data
pub fn upload(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
handle: &svg::Handle,
color: Option<Color>,
[width, height]: [f32; 2],
scale: f32,
state: &mut T::State<'_>,
storage: &mut T,
) -> Option<&T::Entry> {
atlas: &mut Atlas,
) -> Option<&atlas::Entry> {
let id = handle.id();
let (width, height) = (
@ -136,7 +136,9 @@ impl<T: Storage> Cache<T> {
});
}
let allocation = storage.upload(width, height, &rgba, state)?;
let allocation = atlas
.upload(device, queue, encoder, width, height, &rgba)?;
log::debug!("allocating {} {}x{}", id, width, height);
let _ = self.svg_hits.insert(id);
@ -150,7 +152,7 @@ impl<T: Storage> Cache<T> {
}
/// Load svg and upload raster data
pub fn trim(&mut self, storage: &mut T, state: &mut T::State<'_>) {
pub fn trim(&mut self, atlas: &mut Atlas) {
let svg_hits = &self.svg_hits;
let rasterized_hits = &self.rasterized_hits;
@ -159,7 +161,7 @@ impl<T: Storage> Cache<T> {
let retain = rasterized_hits.contains(k);
if !retain {
storage.remove(entry, state);
atlas.remove(entry);
}
retain
@ -169,17 +171,6 @@ impl<T: Storage> Cache<T> {
}
}
impl<T: Storage> Default for Cache<T> {
fn default() -> Self {
Self {
svgs: HashMap::new(),
rasterized: HashMap::new(),
svg_hits: HashSet::new(),
rasterized_hits: HashSet::new(),
}
}
}
impl std::fmt::Debug for Svg {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {