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

Refactor texture image filtering

Browse source 
- Support only `Linear` or `Nearest`
- Simplify `Layer` groups
- Move `FilterMethod` to `Image` and `image::Viewer`
This commit is contained in:
Héctor Ramón Jiménez 2023-11-11 07:02:01 +01:00
parent 75c9afc608
commit a5125d6fea
No known key found for this signature in database
GPG key ID: 7CC46565708259A7
12 changed files with 250 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

49
core/src/image.rs
View file

@ -5,31 +5,11 @@ use std::hash::{Hash, Hasher as _};
use std::path::PathBuf;
use std::sync::Arc;
/// Image filter method
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FilterMethod {
/// Bilinear interpolation
#[default]
Linear,
/// Nearest Neighbor
Nearest,
}
/// Texture filter settings
#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
pub struct TextureFilter {
/// Filter for scaling the image down.
pub min: FilterMethod,
/// Filter for scaling the image up.
pub mag: FilterMethod,
}
/// A handle of some image data.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Handle {
id: u64,
data: Data,
filter: TextureFilter,
}
impl Handle {
@ -76,7 +56,6 @@ impl Handle {
Handle {
id: hasher.finish(),
data,
filter: TextureFilter::default(),
}
}
@ -89,17 +68,6 @@ impl Handle {
pub fn data(&self) -> &Data {
&self.data
}
/// Returns a reference to the [`TextureFilter`].
pub fn filter(&self) -> &TextureFilter {
&self.filter
}
/// Sets the texture filtering methods.
pub fn set_filter(mut self, filter: TextureFilter) -> Self {
self.filter = filter;
self
}
}
impl<T> From<T> for Handle
@ -196,6 +164,16 @@ impl std::fmt::Debug for Data {
}
}
/// Image filtering strategy.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum FilterMethod {
/// Bilinear interpolation.
#[default]
Linear,
/// Nearest neighbor.
Nearest,
}
/// A [`Renderer`] that can render raster graphics.
///
/// [renderer]: crate::renderer
@ -210,5 +188,10 @@ pub trait Renderer: crate::Renderer {
/// Draws an image with the given [`Handle`] and inside the provided
/// `bounds`.
fn draw(&mut self, handle: Self::Handle, bounds: Rectangle);
fn draw(
&mut self,
handle: Self::Handle,
filter_method: FilterMethod,
bounds: Rectangle,
);
}

44
examples/tour/src/main.rs
View file

@ -1,4 +1,4 @@
use iced::alignment;
use iced::alignment::{self, Alignment};
use iced::theme;
use iced::widget::{
checkbox, column, container, horizontal_space, image, radio, row,
@ -126,7 +126,10 @@ impl Steps {
Step::Toggler {
can_continue: false,
},
Step::Image { width: 300 },
Step::Image {
width: 300,
filter_method: image::FilterMethod::Linear,
},
Step::Scrollable,
Step::TextInput {
value: String::new(),
@ -195,6 +198,7 @@ enum Step {
},
Image {
width: u16,
filter_method: image::FilterMethod,
},
Scrollable,
TextInput {
@ -215,6 +219,7 @@ pub enum StepMessage {
TextColorChanged(Color),
LanguageSelected(Language),
ImageWidthChanged(u16),
ImageUseNearestToggled(bool),
InputChanged(String),
ToggleSecureInput(bool),
ToggleTextInputIcon(bool),
@ -265,6 +270,15 @@ impl<'a> Step {
*width = new_width;
}
}
StepMessage::ImageUseNearestToggled(use_nearest) => {
if let Step::Image { filter_method, .. } = self {
*filter_method = if use_nearest {
image::FilterMethod::Nearest
} else {
image::FilterMethod::Linear
};
}
}
StepMessage::InputChanged(new_value) => {
if let Step::TextInput { value, .. } = self {
*value = new_value;
@ -330,7 +344,10 @@ impl<'a> Step {
Step::Toggler { can_continue } => Self::toggler(*can_continue),
Step::Slider { value } => Self::slider(*value),
Step::Text { size, color } => Self::text(*size, *color),
Step::Image { width } => Self::image(*width),
Step::Image {
width,
filter_method,
} => Self::image(*width, *filter_method),
Step::RowsAndColumns { layout, spacing } => {
Self::rows_and_columns(*layout, *spacing)
}
@ -525,16 +542,25 @@ impl<'a> Step {
)
}
fn image(width: u16) -> Column<'a, StepMessage> {
fn image(
width: u16,
filter_method: image::FilterMethod,
) -> Column<'a, StepMessage> {
Self::container("Image")
.push("An image that tries to keep its aspect ratio.")
.push(ferris(width))
.push(ferris(width, filter_method))
.push(slider(100..=500, width, StepMessage::ImageWidthChanged))
.push(
text(format!("Width: {width} px"))
.width(Length::Fill)
.horizontal_alignment(alignment::Horizontal::Center),
)
.push(checkbox(
"Use nearest interpolation",
filter_method == image::FilterMethod::Nearest,
StepMessage::ImageUseNearestToggled,
))
.align_items(Alignment::Center)
}
fn scrollable() -> Column<'a, StepMessage> {
@ -555,7 +581,7 @@ impl<'a> Step {
.horizontal_alignment(alignment::Horizontal::Center),
)
.push(vertical_space(4096))
.push(ferris(300))
.push(ferris(300, image::FilterMethod::Linear))
.push(
text("You made it!")
.width(Length::Fill)
@ -646,7 +672,10 @@ impl<'a> Step {
}
}
fn ferris<'a>(width: u16) -> Container<'a, StepMessage> {
fn ferris<'a>(
width: u16,
filter_method: image::FilterMethod,
) -> Container<'a, StepMessage> {
container(
// This should go away once we unify resource loading on native
// platforms
@ -655,6 +684,7 @@ fn ferris<'a>(width: u16) -> Container<'a, StepMessage> {
} else {
image(format!("{}/images/ferris.png", env!("CARGO_MANIFEST_DIR")))
}
.filter_method(filter_method)
.width(width),
)
.width(Length::Fill)

2
graphics/src/primitive.rs
View file

@ -68,6 +68,8 @@ pub enum Primitive<T> {
Image {
/// The handle of the image
handle: image::Handle,
/// The filter method of the image
filter_method: image::FilterMethod,
/// The bounds of the image
bounds: Rectangle,
},

13
graphics/src/renderer.rs
View file

@ -215,8 +215,17 @@ where
self.backend().dimensions(handle)
}
fn draw(&mut self, handle: image::Handle, bounds: Rectangle) {
self.primitives.push(Primitive::Image { handle, bounds });
fn draw(
&mut self,
handle: image::Handle,
filter_method: image::FilterMethod,
bounds: Rectangle,
) {
self.primitives.push(Primitive::Image {
handle,
filter_method,
bounds,
});
}
}

9
renderer/src/lib.rs
View file

@ -214,8 +214,13 @@ impl<T> crate::core::image::Renderer for Renderer<T> {
delegate!(self, renderer, renderer.dimensions(handle))
}
fn draw(&mut self, handle: crate::core::image::Handle, bounds: Rectangle) {
delegate!(self, renderer, renderer.draw(handle, bounds));
fn draw(
&mut self,
handle: crate::core::image::Handle,
filter_method: crate::core::image::FilterMethod,
bounds: Rectangle,
) {
delegate!(self, renderer, renderer.draw(handle, filter_method, bounds));
}
}

16
tiny_skia/src/backend.rs
View file

@ -445,7 +445,11 @@ impl Backend {
);
}
#[cfg(feature = "image")]
Primitive::Image { handle, bounds } => {
Primitive::Image {
handle,
filter_method,
bounds,
} => {
let physical_bounds = (*bounds + translation) * scale_factor;
if !clip_bounds.intersects(&physical_bounds) {
@ -461,8 +465,14 @@ impl Backend {
)
.post_scale(scale_factor, scale_factor);
self.raster_pipeline
.draw(handle, *bounds, pixels, transform, clip_mask);
self.raster_pipeline.draw(
handle,
*filter_method,
*bounds,
pixels,
transform,
clip_mask,
);
}
#[cfg(not(feature = "image"))]
Primitive::Image { .. } => {

3
tiny_skia/src/raster.rs
View file

@ -28,6 +28,7 @@ impl Pipeline {
pub fn draw(
&mut self,
handle: &raster::Handle,
filter_method: raster::FilterMethod,
bounds: Rectangle,
pixels: &mut tiny_skia::PixmapMut<'_>,
transform: tiny_skia::Transform,
@ -39,7 +40,7 @@ impl Pipeline {
let transform = transform.pre_scale(width_scale, height_scale);
let quality = match handle.filter().mag {
let quality = match filter_method {
raster::FilterMethod::Linear => {
tiny_skia::FilterQuality::Bilinear
}

230
wgpu/src/image.rs
View file

@ -7,8 +7,6 @@ mod raster;
mod vector;
use atlas::Atlas;
use iced_graphics::core::image::{FilterMethod, TextureFilter};
use wgpu::Sampler;
use crate::core::{Rectangle, Size};
use crate::graphics::Transformation;
@ -29,8 +27,6 @@ use crate::core::svg;
#[cfg(feature = "tracing")]
use tracing::info_span;
const SAMPLER_COUNT: usize = 4;
#[derive(Debug)]
pub struct Pipeline {
#[cfg(feature = "image")]
@ -41,30 +37,31 @@ pub struct Pipeline {
pipeline: wgpu::RenderPipeline,
vertices: wgpu::Buffer,
indices: wgpu::Buffer,
sampler: [wgpu::Sampler; SAMPLER_COUNT],
nearest_sampler: wgpu::Sampler,
linear_sampler: wgpu::Sampler,
texture: wgpu::BindGroup,
texture_version: usize,
texture_atlas: Atlas,
texture_layout: wgpu::BindGroupLayout,
constant_layout: wgpu::BindGroupLayout,
layers: Vec<[Option<Layer>; SAMPLER_COUNT]>,
layers: Vec<Layer>,
prepare_layer: usize,
}
#[derive(Debug)]
struct Layer {
uniforms: wgpu::Buffer,
constants: wgpu::BindGroup,
instances: Buffer<Instance>,
instance_count: usize,
nearest: Data,
linear: Data,
}
impl Layer {
fn new(
device: &wgpu::Device,
constant_layout: &wgpu::BindGroupLayout,
sampler: &wgpu::Sampler,
nearest_sampler: &wgpu::Sampler,
linear_sampler: &wgpu::Sampler,
) -> Self {
let uniforms = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("iced_wgpu::image uniforms buffer"),
@ -73,6 +70,59 @@ impl Layer {
mapped_at_creation: false,
});
let nearest =
Data::new(device, constant_layout, nearest_sampler, &uniforms);
let linear =
Data::new(device, constant_layout, linear_sampler, &uniforms);
Self {
uniforms,
nearest,
linear,
}
}
fn prepare(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
nearest_instances: &[Instance],
linear_instances: &[Instance],
transformation: Transformation,
) {
queue.write_buffer(
&self.uniforms,
0,
bytemuck::bytes_of(&Uniforms {
transform: transformation.into(),
}),
);
self.nearest.upload(device, queue, nearest_instances);
self.linear.upload(device, queue, linear_instances);
}
fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
self.nearest.render(render_pass);
self.linear.render(render_pass);
}
}
#[derive(Debug)]
struct Data {
constants: wgpu::BindGroup,
instances: Buffer<Instance>,
instance_count: usize,
}
impl Data {
pub fn new(
device: &wgpu::Device,
constant_layout: &wgpu::BindGroupLayout,
sampler: &wgpu::Sampler,
uniforms: &wgpu::Buffer,
) -> Self {
let constants = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("iced_wgpu::image constants bind group"),
layout: constant_layout,
@ -102,28 +152,18 @@ impl Layer {
);
Self {
uniforms,
constants,
instances,
instance_count: 0,
}
}
fn prepare(
fn upload(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
instances: &[Instance],
transformation: Transformation,
) {
queue.write_buffer(
&self.uniforms,
0,
bytemuck::bytes_of(&Uniforms {
transform: transformation.into(),
}),
);
let _ = self.instances.resize(device, instances.len());
let _ = self.instances.write(queue, 0, instances);
@ -146,37 +186,25 @@ impl Pipeline {
pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
use wgpu::util::DeviceExt;
let to_wgpu = |method: FilterMethod| match method {
FilterMethod::Linear => wgpu::FilterMode::Linear,
FilterMethod::Nearest => wgpu::FilterMode::Nearest,
};
let nearest_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
min_filter: wgpu::FilterMode::Nearest,
mag_filter: wgpu::FilterMode::Nearest,
mipmap_filter: wgpu::FilterMode::Nearest,
..Default::default()
});
let mut sampler: [Option<Sampler>; SAMPLER_COUNT] =
[None, None, None, None];
let filter = [FilterMethod::Linear, FilterMethod::Nearest];
for min in 0..filter.len() {
for mag in 0..filter.len() {
sampler[to_index(&TextureFilter {
min: filter[min],
mag: filter[mag],
})] = Some(device.create_sampler(&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: to_wgpu(filter[mag]),
min_filter: to_wgpu(filter[min]),
mipmap_filter: wgpu::FilterMode::Linear,
..Default::default()
}));
}
}
let sampler = [
sampler[0].take().unwrap(),
sampler[1].take().unwrap(),
sampler[2].take().unwrap(),
sampler[3].take().unwrap(),
];
let linear_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
min_filter: wgpu::FilterMode::Linear,
mag_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
..Default::default()
});
let constant_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
@ -338,7 +366,8 @@ impl Pipeline {
pipeline,
vertices,
indices,
sampler,
nearest_sampler,
linear_sampler,
texture,
texture_version: texture_atlas.layer_count(),
texture_atlas,
@ -381,8 +410,8 @@ impl Pipeline {
#[cfg(feature = "tracing")]
let _ = info_span!("Wgpu::Image", "DRAW").entered();
let mut instances: [Vec<Instance>; SAMPLER_COUNT] =
[Vec::new(), Vec::new(), Vec::new(), Vec::new()];
let nearest_instances: &mut Vec<Instance> = &mut Vec::new();
let linear_instances: &mut Vec<Instance> = &mut Vec::new();
#[cfg(feature = "image")]
let mut raster_cache = self.raster_cache.borrow_mut();
@ -393,7 +422,11 @@ impl Pipeline {
for image in images {
match &image {
#[cfg(feature = "image")]
layer::Image::Raster { handle, bounds } => {
layer::Image::Raster {
handle,
filter_method,
bounds,
} => {
if let Some(atlas_entry) = raster_cache.upload(
device,
encoder,
@ -404,7 +437,12 @@ impl Pipeline {
[bounds.x, bounds.y],
[bounds.width, bounds.height],
atlas_entry,
&mut instances[to_index(handle.filter())],
match filter_method {
image::FilterMethod::Nearest => {
nearest_instances
}
image::FilterMethod::Linear => linear_instances,
},
);
}
}
@ -432,7 +470,7 @@ impl Pipeline {
[bounds.x, bounds.y],
size,
atlas_entry,
&mut instances[to_index(&TextureFilter::default())],
nearest_instances,
);
}
}
@ -441,7 +479,7 @@ impl Pipeline {
}
}
if instances.is_empty() {
if nearest_instances.is_empty() && linear_instances.is_empty() {
return;
}
@ -466,24 +504,24 @@ impl Pipeline {
}
if self.layers.len() <= self.prepare_layer {
self.layers.push([None, None, None, None]);
self.layers.push(Layer::new(
device,
&self.constant_layout,
&self.nearest_sampler,
&self.linear_sampler,
));
}
for (i, instances) in instances.iter_mut().enumerate() {
let layer = &mut self.layers[self.prepare_layer][i];
if !instances.is_empty() {
if layer.is_none() {
*layer = Some(Layer::new(
device,
&self.constant_layout,
&self.sampler[i],
))
}
}
if let Some(layer) = layer {
layer.prepare(device, queue, instances, transformation);
}
}
let layer = &mut self.layers[self.prepare_layer];
layer.prepare(
device,
queue,
&nearest_instances,
&linear_instances,
transformation,
);
self.prepare_layer += 1;
}
@ -493,28 +531,24 @@ impl Pipeline {
bounds: Rectangle<u32>,
render_pass: &mut wgpu::RenderPass<'a>,
) {
if let Some(layer_group) = self.layers.get(layer) {
for layer in layer_group.iter() {
if let Some(layer) = layer {
render_pass.set_pipeline(&self.pipeline);
if let Some(layer) = self.layers.get(layer) {
render_pass.set_pipeline(&self.pipeline);
render_pass.set_scissor_rect(
bounds.x,
bounds.y,
bounds.width,
bounds.height,
);
render_pass.set_scissor_rect(
bounds.x,
bounds.y,
bounds.width,
bounds.height,
);
render_pass.set_bind_group(1, &self.texture, &[]);
render_pass.set_index_buffer(
self.indices.slice(..),
wgpu::IndexFormat::Uint16,
);
render_pass.set_vertex_buffer(0, self.vertices.slice(..));
render_pass.set_bind_group(1, &self.texture, &[]);
render_pass.set_index_buffer(
self.indices.slice(..),
wgpu::IndexFormat::Uint16,
);
render_pass.set_vertex_buffer(0, self.vertices.slice(..));
layer.render(render_pass);
}
}
layer.render(render_pass);
}
}
@ -529,14 +563,6 @@ impl Pipeline {
}
}
fn to_index(filter: &TextureFilter) -> usize {
let to_index = |m| match m {
FilterMethod::Linear => 0,
FilterMethod::Nearest => 1,
};
return (to_index(filter.mag) << 1) | (to_index(filter.min));
}
#[repr(C)]
#[derive(Clone, Copy, Zeroable, Pod)]
pub struct Vertex {
@ -571,7 +597,7 @@ struct Instance {
}
impl Instance {
pub const INITIAL: usize = 1_000;
pub const INITIAL: usize = 20;
}
#[repr(C)]

7
wgpu/src/layer.rs
View file

@ -186,11 +186,16 @@ impl<'a> Layer<'a> {
layer.quads.add(quad, background);
}
Primitive::Image { handle, bounds } => {
Primitive::Image {
handle,
filter_method,
bounds,
} => {
let layer = &mut layers[current_layer];
layer.images.push(Image::Raster {
handle: handle.clone(),
filter_method: *filter_method,
bounds: *bounds + translation,
});
}

3
wgpu/src/layer/image.rs
View file

@ -10,6 +10,9 @@ pub enum Image {
/// The handle of a raster image.
handle: image::Handle,
/// The filter method of a raster image.
filter_method: image::FilterMethod,
/// The bounds of the image.
bounds: Rectangle,
},

29
widget/src/image.rs
View file

@ -13,7 +13,7 @@ use crate::core::{
use std::hash::Hash;
pub use image::{FilterMethod, Handle, TextureFilter};
pub use image::{FilterMethod, Handle};
/// Creates a new [`Viewer`] with the given image `Handle`.
pub fn viewer<Handle>(handle: Handle) -> Viewer<Handle> {
@ -37,6 +37,7 @@ pub struct Image<Handle> {
width: Length,
height: Length,
content_fit: ContentFit,
filter_method: FilterMethod,
}
impl<Handle> Image<Handle> {
@ -47,6 +48,7 @@ impl<Handle> Image<Handle> {
width: Length::Shrink,
height: Length::Shrink,
content_fit: ContentFit::Contain,
filter_method: FilterMethod::default(),
}
}
@ -65,11 +67,15 @@ impl<Handle> Image<Handle> {
/// Sets the [`ContentFit`] of the [`Image`].
///
/// Defaults to [`ContentFit::Contain`]
pub fn content_fit(self, content_fit: ContentFit) -> Self {
Self {
content_fit,
..self
}
pub fn content_fit(mut self, content_fit: ContentFit) -> Self {
self.content_fit = content_fit;
self
}
/// Sets the [`FilterMethod`] of the [`Image`].
pub fn filter_method(mut self, filter_method: FilterMethod) -> Self {
self.filter_method = filter_method;
self
}
}
@ -119,6 +125,7 @@ pub fn draw<Renderer, Handle>(
layout: Layout<'_>,
handle: &Handle,
content_fit: ContentFit,
filter_method: FilterMethod,
) where
Renderer: image::Renderer<Handle = Handle>,
Handle: Clone + Hash,
@ -141,7 +148,7 @@ pub fn draw<Renderer, Handle>(
..bounds
};
renderer.draw(handle.clone(), drawing_bounds + offset);
renderer.draw(handle.clone(), filter_method, drawing_bounds + offset);
};
if adjusted_fit.width > bounds.width || adjusted_fit.height > bounds.height
@ -191,7 +198,13 @@ where
_cursor: mouse::Cursor,
_viewport: &Rectangle,
) {
draw(renderer, layout, &self.handle, self.content_fit);
draw(
renderer,
layout,
&self.handle,
self.content_fit,
self.filter_method,
);
}
}

5
widget/src/image/viewer.rs
View file

@ -22,19 +22,21 @@ pub struct Viewer<Handle> {
max_scale: f32,
scale_step: f32,
handle: Handle,
filter_method: image::FilterMethod,
}
impl<Handle> Viewer<Handle> {
/// Creates a new [`Viewer`] with the given [`State`].
pub fn new(handle: Handle) -> Self {
Viewer {
handle,
padding: 0.0,
width: Length::Shrink,
height: Length::Shrink,
min_scale: 0.25,
max_scale: 10.0,
scale_step: 0.10,
handle,
filter_method: image::FilterMethod::default(),
}
}
@ -329,6 +331,7 @@ where
image::Renderer::draw(
renderer,
self.handle.clone(),
self.filter_method,
Rectangle {
x: bounds.x,
y: bounds.y,