summaryrefslogtreecommitdiffstats
path: root/wgpu/src/image.rs
diff options
context:
space:
mode:
Diffstat (limited to 'wgpu/src/image.rs')
-rw-r--r--wgpu/src/image.rs326
1 files changed, 174 insertions, 152 deletions
diff --git a/wgpu/src/image.rs b/wgpu/src/image.rs
index d3603676..c256ca7e 100644
--- a/wgpu/src/image.rs
+++ b/wgpu/src/image.rs
@@ -9,10 +9,13 @@ mod vector;
use crate::Transformation;
use atlas::Atlas;
+use iced_graphics::layer;
use iced_native::Rectangle;
use std::cell::RefCell;
use std::mem;
+use bytemuck::{Pod, Zeroable};
+
#[cfg(feature = "image")]
use iced_native::image;
@@ -40,6 +43,8 @@ pub struct Pipeline {
impl Pipeline {
pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
+ use wgpu::util::DeviceExt;
+
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
@@ -47,50 +52,52 @@ impl Pipeline {
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear,
- lod_min_clamp: -100.0,
- lod_max_clamp: 100.0,
- compare_function: wgpu::CompareFunction::Always,
+ ..Default::default()
});
let constant_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
- bindings: &[
- wgpu::BindGroupLayoutBinding {
+ label: Some("iced_wgpu::image constants layout"),
+ entries: &[
+ wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX,
- ty: wgpu::BindingType::UniformBuffer { dynamic: false },
+ ty: wgpu::BindingType::UniformBuffer {
+ dynamic: false,
+ min_binding_size: wgpu::BufferSize::new(
+ mem::size_of::<Uniforms>() as u64,
+ ),
+ },
+ count: None,
},
- wgpu::BindGroupLayoutBinding {
+ wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
- ty: wgpu::BindingType::Sampler,
+ ty: wgpu::BindingType::Sampler { comparison: false },
+ count: None,
},
],
});
- let uniforms = Uniforms {
- transform: Transformation::identity().into(),
- };
-
- let uniforms_buffer = device
- .create_buffer_mapped(
- 1,
- wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
- )
- .fill_from_slice(&[uniforms]);
+ let uniforms_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+ label: Some("iced_wgpu::image uniforms buffer"),
+ size: mem::size_of::<Uniforms>() as u64,
+ usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
+ mapped_at_creation: false,
+ });
let constant_bind_group =
device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: Some("iced_wgpu::image constants bind group"),
layout: &constant_layout,
- bindings: &[
- wgpu::Binding {
+ entries: &[
+ wgpu::BindGroupEntry {
binding: 0,
- resource: wgpu::BindingResource::Buffer {
- buffer: &uniforms_buffer,
- range: 0..std::mem::size_of::<Uniforms>() as u64,
- },
+ resource: wgpu::BindingResource::Buffer(
+ uniforms_buffer.slice(..),
+ ),
},
- wgpu::Binding {
+ wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&sampler),
},
@@ -99,36 +106,38 @@ impl Pipeline {
let texture_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
- bindings: &[wgpu::BindGroupLayoutBinding {
+ label: Some("iced_wgpu::image texture atlas layout"),
+ entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::SampledTexture {
- multisampled: false,
dimension: wgpu::TextureViewDimension::D2,
+ component_type: wgpu::TextureComponentType::Float,
+ multisampled: false,
},
+ count: None,
}],
});
let layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+ label: Some("iced_wgpu::image pipeline layout"),
+ push_constant_ranges: &[],
bind_group_layouts: &[&constant_layout, &texture_layout],
});
- let vs = include_bytes!("shader/image.vert.spv");
- let vs_module = device.create_shader_module(
- &wgpu::read_spirv(std::io::Cursor::new(&vs[..]))
- .expect("Read image vertex shader as SPIR-V"),
- );
+ let vs_module = device.create_shader_module(wgpu::include_spirv!(
+ "shader/image.vert.spv"
+ ));
- let fs = include_bytes!("shader/image.frag.spv");
- let fs_module = device.create_shader_module(
- &wgpu::read_spirv(std::io::Cursor::new(&fs[..]))
- .expect("Read image fragment shader as SPIR-V"),
- );
+ let fs_module = device.create_shader_module(wgpu::include_spirv!(
+ "shader/image.frag.spv"
+ ));
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
- layout: &layout,
+ label: Some("iced_wgpu::image pipeline"),
+ layout: Some(&layout),
vertex_stage: wgpu::ProgrammableStageDescriptor {
module: &vs_module,
entry_point: "main",
@@ -140,9 +149,7 @@ impl Pipeline {
rasterization_state: Some(wgpu::RasterizationStateDescriptor {
front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None,
- depth_bias: 0,
- depth_bias_slope_scale: 0.0,
- depth_bias_clamp: 0.0,
+ ..Default::default()
}),
primitive_topology: wgpu::PrimitiveTopology::TriangleList,
color_states: &[wgpu::ColorStateDescriptor {
@@ -160,72 +167,83 @@ impl Pipeline {
write_mask: wgpu::ColorWrite::ALL,
}],
depth_stencil_state: None,
- index_format: wgpu::IndexFormat::Uint16,
- vertex_buffers: &[
- wgpu::VertexBufferDescriptor {
- stride: mem::size_of::<Vertex>() as u64,
- step_mode: wgpu::InputStepMode::Vertex,
- attributes: &[wgpu::VertexAttributeDescriptor {
- shader_location: 0,
- format: wgpu::VertexFormat::Float2,
- offset: 0,
- }],
- },
- wgpu::VertexBufferDescriptor {
- stride: mem::size_of::<Instance>() as u64,
- step_mode: wgpu::InputStepMode::Instance,
- attributes: &[
- wgpu::VertexAttributeDescriptor {
- shader_location: 1,
+ vertex_state: wgpu::VertexStateDescriptor {
+ index_format: wgpu::IndexFormat::Uint16,
+ vertex_buffers: &[
+ wgpu::VertexBufferDescriptor {
+ stride: mem::size_of::<Vertex>() as u64,
+ step_mode: wgpu::InputStepMode::Vertex,
+ attributes: &[wgpu::VertexAttributeDescriptor {
+ shader_location: 0,
format: wgpu::VertexFormat::Float2,
offset: 0,
- },
- wgpu::VertexAttributeDescriptor {
- shader_location: 2,
- format: wgpu::VertexFormat::Float2,
- offset: 4 * 2,
- },
- wgpu::VertexAttributeDescriptor {
- shader_location: 3,
- format: wgpu::VertexFormat::Float2,
- offset: 4 * 4,
- },
- wgpu::VertexAttributeDescriptor {
- shader_location: 4,
- format: wgpu::VertexFormat::Float2,
- offset: 4 * 6,
- },
- wgpu::VertexAttributeDescriptor {
- shader_location: 5,
- format: wgpu::VertexFormat::Uint,
- offset: 4 * 8,
- },
- ],
- },
- ],
+ }],
+ },
+ wgpu::VertexBufferDescriptor {
+ stride: mem::size_of::<Instance>() as u64,
+ step_mode: wgpu::InputStepMode::Instance,
+ attributes: &[
+ wgpu::VertexAttributeDescriptor {
+ shader_location: 1,
+ format: wgpu::VertexFormat::Float2,
+ offset: 0,
+ },
+ wgpu::VertexAttributeDescriptor {
+ shader_location: 2,
+ format: wgpu::VertexFormat::Float2,
+ offset: 4 * 2,
+ },
+ wgpu::VertexAttributeDescriptor {
+ shader_location: 3,
+ format: wgpu::VertexFormat::Float2,
+ offset: 4 * 4,
+ },
+ wgpu::VertexAttributeDescriptor {
+ shader_location: 4,
+ format: wgpu::VertexFormat::Float2,
+ offset: 4 * 6,
+ },
+ wgpu::VertexAttributeDescriptor {
+ shader_location: 5,
+ format: wgpu::VertexFormat::Uint,
+ offset: 4 * 8,
+ },
+ ],
+ },
+ ],
+ },
sample_count: 1,
sample_mask: !0,
alpha_to_coverage_enabled: false,
});
- let vertices = device
- .create_buffer_mapped(QUAD_VERTS.len(), wgpu::BufferUsage::VERTEX)
- .fill_from_slice(&QUAD_VERTS);
+ let vertices =
+ device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+ label: Some("iced_wgpu::image vertex buffer"),
+ contents: bytemuck::cast_slice(&QUAD_VERTS),
+ usage: wgpu::BufferUsage::VERTEX,
+ });
- let indices = device
- .create_buffer_mapped(QUAD_INDICES.len(), wgpu::BufferUsage::INDEX)
- .fill_from_slice(&QUAD_INDICES);
+ let indices =
+ device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+ label: Some("iced_wgpu::image index buffer"),
+ contents: bytemuck::cast_slice(&QUAD_INDICES),
+ usage: wgpu::BufferUsage::INDEX,
+ });
let instances = device.create_buffer(&wgpu::BufferDescriptor {
+ label: Some("iced_wgpu::image instance buffer"),
size: mem::size_of::<Instance>() as u64 * Instance::MAX as u64,
usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
+ mapped_at_creation: false,
});
let texture_atlas = Atlas::new(device);
let texture = device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: Some("iced_wgpu::image texture atlas bind group"),
layout: &texture_layout,
- bindings: &[wgpu::Binding {
+ entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(
&texture_atlas.view(),
@@ -271,9 +289,10 @@ impl Pipeline {
pub fn draw(
&mut self,
- device: &mut wgpu::Device,
+ device: &wgpu::Device,
+ staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder,
- images: &[Image],
+ images: &[layer::Image],
transformation: Transformation,
bounds: Rectangle<u32>,
target: &wgpu::TextureView,
@@ -288,31 +307,48 @@ impl Pipeline {
let mut vector_cache = self.vector_cache.borrow_mut();
for image in images {
- match &image.handle {
+ match &image {
#[cfg(feature = "image")]
- Handle::Raster(handle) => {
+ layer::Image::Raster { handle, bounds } => {
if let Some(atlas_entry) = raster_cache.upload(
handle,
device,
encoder,
&mut self.texture_atlas,
) {
- add_instances(image, atlas_entry, instances);
+ add_instances(
+ [bounds.x, bounds.y],
+ [bounds.width, bounds.height],
+ atlas_entry,
+ instances,
+ );
}
}
+ #[cfg(not(feature = "image"))]
+ layer::Image::Raster { .. } => {}
+
#[cfg(feature = "svg")]
- Handle::Vector(handle) => {
+ layer::Image::Vector { handle, bounds } => {
+ let size = [bounds.width, bounds.height];
+
if let Some(atlas_entry) = vector_cache.upload(
handle,
- image.size,
+ size,
_scale,
device,
encoder,
&mut self.texture_atlas,
) {
- add_instances(image, atlas_entry, instances);
+ add_instances(
+ [bounds.x, bounds.y],
+ size,
+ atlas_entry,
+ instances,
+ );
}
}
+ #[cfg(not(feature = "svg"))]
+ layer::Image::Vector { .. } => {}
}
}
@@ -327,8 +363,9 @@ impl Pipeline {
self.texture =
device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: Some("iced_wgpu::image texture atlas bind group"),
layout: &self.texture_layout,
- bindings: &[wgpu::Binding {
+ entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(
&self.texture_atlas.view(),
@@ -339,23 +376,20 @@ impl Pipeline {
self.texture_version = texture_version;
}
- let uniforms_buffer = device
- .create_buffer_mapped(1, wgpu::BufferUsage::COPY_SRC)
- .fill_from_slice(&[Uniforms {
- transform: transformation.into(),
- }]);
-
- encoder.copy_buffer_to_buffer(
- &uniforms_buffer,
- 0,
- &self.uniforms,
- 0,
- std::mem::size_of::<Uniforms>() as u64,
- );
+ {
+ let mut uniforms_buffer = staging_belt.write_buffer(
+ encoder,
+ &self.uniforms,
+ 0,
+ wgpu::BufferSize::new(mem::size_of::<Uniforms>() as u64)
+ .unwrap(),
+ device,
+ );
- let instances_buffer = device
- .create_buffer_mapped(instances.len(), wgpu::BufferUsage::COPY_SRC)
- .fill_from_slice(&instances);
+ uniforms_buffer.copy_from_slice(bytemuck::bytes_of(&Uniforms {
+ transform: transformation.into(),
+ }));
+ }
let mut i = 0;
let total = instances.len();
@@ -364,27 +398,30 @@ impl Pipeline {
let end = (i + Instance::MAX).min(total);
let amount = end - i;
- encoder.copy_buffer_to_buffer(
- &instances_buffer,
- (i * std::mem::size_of::<Instance>()) as u64,
+ let mut instances_buffer = staging_belt.write_buffer(
+ encoder,
&self.instances,
0,
- (amount * std::mem::size_of::<Instance>()) as u64,
+ wgpu::BufferSize::new(
+ (amount * std::mem::size_of::<Instance>()) as u64,
+ )
+ .unwrap(),
+ device,
);
+ instances_buffer.copy_from_slice(bytemuck::cast_slice(
+ &instances[i..i + amount],
+ ));
+
let mut render_pass =
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[
wgpu::RenderPassColorAttachmentDescriptor {
attachment: target,
resolve_target: None,
- load_op: wgpu::LoadOp::Load,
- store_op: wgpu::StoreOp::Store,
- clear_color: wgpu::Color {
- r: 0.0,
- g: 0.0,
- b: 0.0,
- a: 0.0,
+ ops: wgpu::Operations {
+ load: wgpu::LoadOp::Load,
+ store: true,
},
},
],
@@ -394,11 +431,9 @@ impl Pipeline {
render_pass.set_pipeline(&self.pipeline);
render_pass.set_bind_group(0, &self.constants, &[]);
render_pass.set_bind_group(1, &self.texture, &[]);
- render_pass.set_index_buffer(&self.indices, 0);
- render_pass.set_vertex_buffers(
- 0,
- &[(&self.vertices, 0), (&self.instances, 0)],
- );
+ render_pass.set_index_buffer(self.indices.slice(..));
+ render_pass.set_vertex_buffer(0, self.vertices.slice(..));
+ render_pass.set_vertex_buffer(1, self.instances.slice(..));
render_pass.set_scissor_rect(
bounds.x,
@@ -426,22 +461,8 @@ impl Pipeline {
}
}
-pub struct Image {
- pub handle: Handle,
- pub position: [f32; 2],
- pub size: [f32; 2],
-}
-
-pub enum Handle {
- #[cfg(feature = "image")]
- Raster(image::Handle),
-
- #[cfg(feature = "svg")]
- Vector(svg::Handle),
-}
-
#[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Zeroable, Pod)]
pub struct Vertex {
_position: [f32; 2],
}
@@ -464,7 +485,7 @@ const QUAD_VERTS: [Vertex; 4] = [
];
#[repr(C)]
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Zeroable, Pod)]
struct Instance {
_position: [f32; 2],
_size: [f32; 2],
@@ -478,28 +499,29 @@ impl Instance {
}
#[repr(C)]
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Zeroable, Pod)]
struct Uniforms {
transform: [f32; 16],
}
fn add_instances(
- image: &Image,
+ image_position: [f32; 2],
+ image_size: [f32; 2],
entry: &atlas::Entry,
instances: &mut Vec<Instance>,
) {
match entry {
atlas::Entry::Contiguous(allocation) => {
- add_instance(image.position, image.size, allocation, instances);
+ add_instance(image_position, image_size, allocation, instances);
}
atlas::Entry::Fragmented { fragments, size } => {
- let scaling_x = image.size[0] / size.0 as f32;
- let scaling_y = image.size[1] / size.1 as f32;
+ let scaling_x = image_size[0] / size.0 as f32;
+ let scaling_y = image_size[1] / size.1 as f32;
for fragment in fragments {
let allocation = &fragment.allocation;
- let [x, y] = image.position;
+ let [x, y] = image_position;
let (fragment_x, fragment_y) = fragment.position;
let (fragment_width, fragment_height) = allocation.size();
generated by cgit (git 2.34.1) at 2025-05-20 12:31:01 +0000