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

Implement allocating large images across multiple texture array layers.

Browse source
This commit is contained in:
Malte Veerman 2020-01-16 14:03:46 +01:00 • committed by Héctor Ramón Jiménez
parent 2f77a6bf5a
commit 3f38835105
3 changed files with 552 additions and 221 deletions
Download patch file Download diff file Expand all files Collapse all files

35
wgpu/src/image/raster.rs
View file

@ -1,19 +1,15 @@
use crate::image::AtlasArray;
use crate::image::{TextureArray, ImageAllocation};
use iced_native::image;
use std::{
collections::{HashMap, HashSet},
};
use guillotiere::{Allocation, Size};
use guillotiere::Size;
use debug_stub_derive::*;
#[derive(DebugStub)]
pub enum Memory {
Host(::image::ImageBuffer<::image::Bgra<u8>, Vec<u8>>),
Device {
layer: u32,
#[debug_stub="ReplacementValue"]
allocation: Allocation,
},
Device(ImageAllocation),
NotFound,
Invalid,
}
@ -22,10 +18,7 @@ impl Memory {
pub fn dimensions(&self) -> (u32, u32) {
match self {
Memory::Host(image) => image.dimensions(),
Memory::Device { allocation, .. } => {
let size = &allocation.rectangle.size();
(size.width as u32, size.height as u32)
},
Memory::Device(allocation) => allocation.size(),
Memory::NotFound => (1, 1),
Memory::Invalid => (1, 1),
}
@ -77,7 +70,7 @@ impl Cache {
handle: &image::Handle,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
atlas_array: &mut AtlasArray,
atlas_array: &mut TextureArray,
) -> &Memory {
let _ = self.load(handle);
@ -87,29 +80,23 @@ impl Cache {
let (width, height) = image.dimensions();
let size = Size::new(width as i32, height as i32);
let (layer, allocation) = atlas_array.allocate(size).unwrap_or_else(|| {
atlas_array.grow(1, device, encoder);
atlas_array.allocate(size).unwrap()
});
let allocation = atlas_array.allocate(size);
let flat_samples = image.as_flat_samples();
let slice = flat_samples.as_slice();
atlas_array.upload(image, &allocation, device, encoder);
atlas_array.upload(slice, layer, &allocation, device, encoder);
*memory = Memory::Device { layer, allocation };
*memory = Memory::Device(allocation);
}
memory
}
pub fn trim(&mut self, atlas_array: &mut AtlasArray) {
pub fn trim(&mut self, texture_array: &mut TextureArray) {
let hits = &self.hits;
for (id, mem) in &self.map {
if let Memory::Device { layer, allocation } = mem {
if let Memory::Device(allocation) = mem {
if !hits.contains(&id) {
atlas_array.deallocate(*layer, allocation);
texture_array.deallocate(allocation);
}
}
}

27
wgpu/src/image/vector.rs
View file

@ -1,9 +1,9 @@
use crate::image::AtlasArray;
use crate::image::{TextureArray, ImageAllocation};
use iced_native::svg;
use std::{
collections::{HashMap, HashSet},
};
use guillotiere::{Allocation, Size};
use guillotiere::Size;
use debug_stub_derive::*;
#[derive(DebugStub)]
@ -32,7 +32,7 @@ impl Svg {
pub struct Cache {
svgs: HashMap<u64, Svg>,
#[debug_stub="ReplacementValue"]
rasterized: HashMap<(u64, u32, u32), (u32, Allocation)>,
rasterized: HashMap<(u64, u32, u32), ImageAllocation>,
svg_hits: HashSet<u64>,
rasterized_hits: HashSet<(u64, u32, u32)>,
}
@ -70,8 +70,8 @@ impl Cache {
scale: f32,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
atlas_array: &mut AtlasArray,
) -> Option<&(u32, Allocation)> {
texture_array: &mut TextureArray,
) -> Option<&ImageAllocation> {
let id = handle.id();
let (width, height) = (
@ -100,10 +100,7 @@ impl Cache {
let size = Size::new(width as i32, height as i32);
let (layer, allocation) = atlas_array.allocate(size).unwrap_or_else(|| {
atlas_array.grow(1, device, encoder);
atlas_array.allocate(size).unwrap()
});
let array_allocation = texture_array.allocate(size);
// TODO: Optimize!
// We currently rerasterize the SVG when its size changes. This is slow
@ -124,15 +121,13 @@ impl Cache {
&mut canvas,
);
let slice = canvas.get_data();
atlas_array.upload(slice, layer, &allocation, device, encoder);
texture_array.upload(&canvas, &array_allocation, device, encoder);
let _ = self.svg_hits.insert(id);
let _ = self.rasterized_hits.insert((id, width, height));
let _ = self
.rasterized
.insert((id, width, height), (layer, allocation));
.insert((id, width, height), array_allocation);
self.rasterized.get(&(id, width, height))
}
@ -140,13 +135,13 @@ impl Cache {
}
}
pub fn trim(&mut self, atlas_array: &mut AtlasArray) {
pub fn trim(&mut self, texture_array: &mut TextureArray) {
let svg_hits = &self.svg_hits;
let rasterized_hits = &self.rasterized_hits;
for (k, (layer, allocation)) in &self.rasterized {
for (k, allocation) in &self.rasterized {
if !rasterized_hits.contains(k) {
atlas_array.deallocate(*layer, allocation);
texture_array.deallocate(allocation);
}
}