reivilibre/iced-mobile
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix multiple issues from the refactoring

Browse Source 
- Update texture view on grow
- Fix atlas texture coordinates
- Fix fragmented uploads
This commit is contained in:
Héctor Ramón Jiménez 2020-02-26 18:49:46 +01:00
parent c58d94f3fd
commit 48d70280eb
4 changed files with 86 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
wgpu/src/image.rs
View File

@ -319,6 +319,8 @@ impl Pipeline {
let texture_version = self.texture_atlas.layer_count();
if self.texture_version != texture_version {
log::info!("Atlas has grown. Recreating bind group...");
self.texture =
device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &self.texture_layout,
@ -525,12 +527,12 @@ fn add_instance(
_position: position,
_size: size,
_position_in_atlas: [
x as f32 / atlas::SIZE as f32,
y as f32 / atlas::SIZE as f32,
(x as f32 + 0.5) / atlas::SIZE as f32,
(y as f32 + 0.5) / atlas::SIZE as f32,
],
_size_in_atlas: [
width as f32 / atlas::SIZE as f32,
height as f32 / atlas::SIZE as f32,
(width as f32 - 0.5) / atlas::SIZE as f32,
(height as f32 - 0.5) / atlas::SIZE as f32,
],
_layer: layer as u32,
};

5
wgpu/src/image/raster.rs
View File

@ -83,10 +83,9 @@ impl Cache {
if let Memory::Host(image) = memory {
let (width, height) = image.dimensions();
let allocation =
atlas.upload(width, height, &image, device, encoder)?;
let entry = atlas.upload(width, height, &image, device, encoder)?;
*memory = Memory::Device(allocation);
*memory = Memory::Device(entry);
}
if let Memory::Device(allocation) = memory {

52
wgpu/src/texture/atlas.rs
View File

@ -10,7 +10,7 @@ pub use layer::Layer;
use allocator::Allocator;
pub const SIZE: u32 = 4096;
pub const SIZE: u32 = 2048;
#[derive(Debug)]
pub struct Atlas {
@ -78,24 +78,33 @@ impl Atlas {
entry
};
log::info!("Allocated atlas entry: {:?}", entry);
let buffer = device
.create_buffer_mapped(data.len(), wgpu::BufferUsage::COPY_SRC)
.fill_from_slice(data);
match &entry {
Entry::Contiguous(allocation) => {
self.upload_texture(&buffer, 0, &allocation, encoder);
self.upload_allocation(
&buffer,
width,
height,
0,
&allocation,
encoder,
);
}
Entry::Fragmented { fragments, .. } => {
for fragment in fragments {
let (x, y) = fragment.allocation.position();
let (x, y) = fragment.position;
let offset = (y * width + x) as usize * 4;
let offset =
(y * height + x) as usize * std::mem::size_of::<C>();
self.upload_texture(
self.upload_allocation(
&buffer,
offset as u64,
width,
height,
offset,
&fragment.allocation,
encoder,
);
@ -103,6 +112,8 @@ impl Atlas {
}
}
log::info!("Current atlas: {:?}", &self);
Some(entry)
}
@ -204,10 +215,12 @@ impl Atlas {
None
}
fn upload_texture(
fn upload_allocation(
&mut self,
buffer: &wgpu::Buffer,
offset: u64,
image_width: u32,
image_height: u32,
offset: usize,
allocation: &Allocation,
encoder: &mut wgpu::CommandEncoder,
) {
@ -224,9 +237,9 @@ impl Atlas {
encoder.copy_buffer_to_texture(
wgpu::BufferCopyView {
buffer,
offset,
row_pitch: 4 * width,
image_height: height,
offset: offset as u64,
row_pitch: 4 * image_width,
image_height,
},
wgpu::TextureCopyView {
texture: &self.texture,
@ -258,7 +271,7 @@ impl Atlas {
height: SIZE,
depth: 1,
},
array_layer_count: (self.layers.len() + amount) as u32,
array_layer_count: self.layers.len() as u32,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
@ -268,7 +281,11 @@ impl Atlas {
| wgpu::TextureUsage::SAMPLED,
});
for (i, layer) in self.layers.iter_mut().enumerate() {
let amount_to_copy = self.layers.len() - amount;
for (i, layer) in
self.layers.iter_mut().take(amount_to_copy).enumerate()
{
if layer.is_empty() {
continue;
}
@ -302,10 +319,7 @@ impl Atlas {
);
}
for _ in 0..amount {
self.layers.push(Layer::Empty);
}
self.texture = new_texture;
self.texture_view = self.texture.create_default_view();
}
}

61
wgpu/src/texture/atlas/allocator.rs
View File

@ -2,41 +2,70 @@ use guillotiere::{AtlasAllocator, Size};
pub struct Allocator {
raw: AtlasAllocator,
size: u32,
}
impl Allocator {
const PADDING: u32 = 1;
pub fn new(size: u32) -> Allocator {
let raw = AtlasAllocator::new(Size::new(size as i32, size as i32));
Allocator { raw }
Allocator { raw, size }
}
pub fn allocate(&mut self, width: u32, height: u32) -> Option<Region> {
let allocation = self
.raw
.allocate(Size::new(width as i32 + 2, height as i32 + 2))?;
let padding = (
if width + Self::PADDING * 2 < self.size {
Self::PADDING
} else {
0
},
if height + Self::PADDING * 2 < self.size {
Self::PADDING
} else {
0
},
);
Some(Region(allocation))
let allocation = self.raw.allocate(Size::new(
(width + padding.0 * 2) as i32,
(height + padding.1 * 2) as i32,
))?;
Some(Region {
allocation,
padding,
})
}
pub fn deallocate(&mut self, region: Region) {
self.raw.deallocate(region.0.id);
self.raw.deallocate(region.allocation.id);
}
}
pub struct Region(guillotiere::Allocation);
pub struct Region {
allocation: guillotiere::Allocation,
padding: (u32, u32),
}
impl Region {
pub fn position(&self) -> (u32, u32) {
let rectangle = &self.0.rectangle;
let rectangle = &self.allocation.rectangle;
(rectangle.min.x as u32 + 1, rectangle.min.y as u32 + 1)
(
rectangle.min.x as u32 + self.padding.0,
rectangle.min.y as u32 + self.padding.1,
)
}
pub fn size(&self) -> (u32, u32) {
let size = self.0.rectangle.size();
let size = self.allocation.rectangle.size();
(size.width as u32 - 2, size.height as u32 - 2)
(
size.width as u32 - self.padding.0 * 2,
size.height as u32 - self.padding.1 * 2,
)
}
}
@ -48,10 +77,10 @@ impl std::fmt::Debug for Allocator {
impl std::fmt::Debug for Region {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"Region {{ id: {:?}, rectangle: {:?} }}",
self.0.id, self.0.rectangle
)
f.debug_struct("Region")
.field("id", &self.allocation.id)
.field("rectangle", &self.allocation.rectangle)
.field("padding", &self.padding)
.finish()
}
}