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

Use array of atlases instead of one growing indefinitely.

Browse source
This commit is contained in:
Malte Veerman 2020-01-13 15:33:12 +01:00 • committed by Héctor Ramón Jiménez
parent 8562a4c986
commit 2f77a6bf5a
5 changed files with 259 additions and 280 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,17 +1,19 @@
use crate::image::AtlasArray;
use iced_native::image;
use std::{
collections::{HashMap, HashSet},
};
use guillotiere::{Allocation, AtlasAllocator, Size};
use guillotiere::{Allocation, Size};
use debug_stub_derive::*;
#[derive(DebugStub)]
pub enum Memory {
Host(::image::ImageBuffer<::image::Bgra<u8>, Vec<u8>>),
Device(
Device {
layer: u32,
#[debug_stub="ReplacementValue"]
Allocation
),
allocation: Allocation,
},
NotFound,
Invalid,
}
@ -20,7 +22,7 @@ impl Memory {
pub fn dimensions(&self) -> (u32, u32) {
match self {
Memory::Host(image) => image.dimensions(),
Memory::Device(allocation) => {
Memory::Device { allocation, .. } => {
let size = &allocation.rectangle.size();
(size.width as u32, size.height as u32)
},
@ -75,8 +77,7 @@ impl Cache {
handle: &image::Handle,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
allocator: &mut AtlasAllocator,
atlas: &mut wgpu::Texture,
atlas_array: &mut AtlasArray,
) -> &Memory {
let _ = self.load(handle);
@ -86,119 +87,29 @@ impl Cache {
let (width, height) = image.dimensions();
let size = Size::new(width as i32, height as i32);
let old_atlas_size = allocator.size();
let allocation;
let (layer, allocation) = atlas_array.allocate(size).unwrap_or_else(|| {
atlas_array.grow(1, device, encoder);
atlas_array.allocate(size).unwrap()
});
loop {
if let Some(a) = allocator.allocate(size) {
allocation = a;
break;
}
let flat_samples = image.as_flat_samples();
let slice = flat_samples.as_slice();
allocator.grow(allocator.size() * 2);
}
atlas_array.upload(slice, layer, &allocation, device, encoder);
let new_atlas_size = allocator.size();
if new_atlas_size != old_atlas_size {
let new_atlas = device.create_texture(&wgpu::TextureDescriptor {
size: wgpu::Extent3d {
width: new_atlas_size.width as u32,
height: new_atlas_size.height as u32,
depth: 1,
},
array_layer_count: 1,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Bgra8UnormSrgb,
usage: wgpu::TextureUsage::COPY_DST
| wgpu::TextureUsage::COPY_SRC
| wgpu::TextureUsage::SAMPLED,
});
encoder.copy_texture_to_texture(
wgpu::TextureCopyView {
texture: atlas,
array_layer: 0,
mip_level: 0,
origin: wgpu::Origin3d {
x: 0.0,
y: 0.0,
z: 0.0,
},
},
wgpu::TextureCopyView {
texture: &new_atlas,
array_layer: 0,
mip_level: 0,
origin: wgpu::Origin3d {
x: 0.0,
y: 0.0,
z: 0.0,
},
},
wgpu::Extent3d {
width: old_atlas_size.width as u32,
height: old_atlas_size.height as u32,
depth: 1,
}
);
*atlas = new_atlas;
}
let extent = wgpu::Extent3d {
width,
height,
depth: 1,
};
let temp_buf = {
let flat_samples = image.as_flat_samples();
let slice = flat_samples.as_slice();
device
.create_buffer_mapped(
slice.len(),
wgpu::BufferUsage::COPY_SRC,
)
.fill_from_slice(slice)
};
encoder.copy_buffer_to_texture(
wgpu::BufferCopyView {
buffer: &temp_buf,
offset: 0,
row_pitch: 4 * width,
image_height: height,
},
wgpu::TextureCopyView {
texture: atlas,
array_layer: 0,
mip_level: 0,
origin: wgpu::Origin3d {
x: allocation.rectangle.min.x as f32,
y: allocation.rectangle.min.y as f32,
z: 0.0,
},
},
extent,
);
*memory = Memory::Device(allocation);
*memory = Memory::Device { layer, allocation };
}
memory
}
pub fn trim(&mut self, allocator: &mut AtlasAllocator) {
pub fn trim(&mut self, atlas_array: &mut AtlasArray) {
let hits = &self.hits;
for (id, mem) in &mut self.map {
if let Memory::Device(allocation) = mem {
for (id, mem) in &self.map {
if let Memory::Device { layer, allocation } = mem {
if !hits.contains(&id) {
allocator.deallocate(allocation.id);
atlas_array.deallocate(*layer, allocation);
}
}
}