summaryrefslogtreecommitdiffstats
path: root/wgpu/src/triangle.rs
diff options
context:
space:
mode:
Diffstat (limited to 'wgpu/src/triangle.rs')
-rw-r--r--wgpu/src/triangle.rs369
1 files changed, 209 insertions, 160 deletions
diff --git a/wgpu/src/triangle.rs b/wgpu/src/triangle.rs
index 51a6f954..61a771d8 100644
--- a/wgpu/src/triangle.rs
+++ b/wgpu/src/triangle.rs
@@ -1,18 +1,23 @@
//! Draw meshes of triangles.
use crate::{settings, Transformation};
-use iced_native::{Point, Rectangle};
+use iced_graphics::layer;
+
+use bytemuck::{Pod, Zeroable};
use std::mem;
+pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
+
mod msaa;
-const UNIFORM_BUFFER_SIZE: usize = 100;
-const VERTEX_BUFFER_SIZE: usize = 100_000;
-const INDEX_BUFFER_SIZE: usize = 100_000;
+const UNIFORM_BUFFER_SIZE: usize = 50;
+const VERTEX_BUFFER_SIZE: usize = 10_000;
+const INDEX_BUFFER_SIZE: usize = 10_000;
#[derive(Debug)]
pub(crate) struct Pipeline {
pipeline: wgpu::RenderPipeline,
blit: Option<msaa::Blit>,
+ constants_layout: wgpu::BindGroupLayout,
constants: wgpu::BindGroup,
uniforms_buffer: Buffer<Uniforms>,
vertex_buffer: Buffer<Vertex2D>,
@@ -21,6 +26,7 @@ pub(crate) struct Pipeline {
#[derive(Debug)]
struct Buffer<T> {
+ label: &'static str,
raw: wgpu::Buffer,
size: usize,
usage: wgpu::BufferUsage,
@@ -29,16 +35,20 @@ struct Buffer<T> {
impl<T> Buffer<T> {
pub fn new(
+ label: &'static str,
device: &wgpu::Device,
size: usize,
usage: wgpu::BufferUsage,
) -> Self {
let raw = device.create_buffer(&wgpu::BufferDescriptor {
+ label: Some(label),
size: (std::mem::size_of::<T>() * size) as u64,
usage,
+ mapped_at_creation: false,
});
Buffer {
+ label,
raw,
size,
usage,
@@ -46,34 +56,48 @@ impl<T> Buffer<T> {
}
}
- pub fn ensure_capacity(&mut self, device: &wgpu::Device, size: usize) {
- if self.size < size {
+ pub fn expand(&mut self, device: &wgpu::Device, size: usize) -> bool {
+ let needs_resize = self.size < size;
+
+ if needs_resize {
self.raw = device.create_buffer(&wgpu::BufferDescriptor {
+ label: Some(self.label),
size: (std::mem::size_of::<T>() * size) as u64,
usage: self.usage,
+ mapped_at_creation: false,
});
self.size = size;
}
+
+ needs_resize
}
}
impl Pipeline {
pub fn new(
- device: &mut wgpu::Device,
+ device: &wgpu::Device,
format: wgpu::TextureFormat,
antialiasing: Option<settings::Antialiasing>,
) -> Pipeline {
- let constant_layout =
+ let constants_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
- bindings: &[wgpu::BindGroupLayoutBinding {
+ label: Some("iced_wgpu::triangle uniforms layout"),
+ entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX,
- ty: wgpu::BindingType::UniformBuffer { dynamic: true },
+ ty: wgpu::BindingType::UniformBuffer {
+ dynamic: true,
+ min_binding_size: wgpu::BufferSize::new(
+ mem::size_of::<Uniforms>() as u64,
+ ),
+ },
+ count: None,
}],
});
let constants_buffer = Buffer::new(
+ "iced_wgpu::triangle uniforms buffer",
device,
UNIFORM_BUFFER_SIZE,
wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
@@ -81,36 +105,37 @@ impl Pipeline {
let constant_bind_group =
device.create_bind_group(&wgpu::BindGroupDescriptor {
- layout: &constant_layout,
- bindings: &[wgpu::Binding {
+ label: Some("iced_wgpu::triangle uniforms bind group"),
+ layout: &constants_layout,
+ entries: &[wgpu::BindGroupEntry {
binding: 0,
- resource: wgpu::BindingResource::Buffer {
- buffer: &constants_buffer.raw,
- range: 0..std::mem::size_of::<Uniforms>() as u64,
- },
+ resource: wgpu::BindingResource::Buffer(
+ constants_buffer
+ .raw
+ .slice(0..std::mem::size_of::<Uniforms>() as u64),
+ ),
}],
});
let layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
- bind_group_layouts: &[&constant_layout],
+ label: Some("iced_wgpu::triangle pipeline layout"),
+ push_constant_ranges: &[],
+ bind_group_layouts: &[&constants_layout],
});
- let vs = include_bytes!("shader/triangle.vert.spv");
- let vs_module = device.create_shader_module(
- &wgpu::read_spirv(std::io::Cursor::new(&vs[..]))
- .expect("Read triangle vertex shader as SPIR-V"),
- );
+ let vs_module = device.create_shader_module(wgpu::include_spirv!(
+ "shader/triangle.vert.spv"
+ ));
- let fs = include_bytes!("shader/triangle.frag.spv");
- let fs_module = device.create_shader_module(
- &wgpu::read_spirv(std::io::Cursor::new(&fs[..]))
- .expect("Read triangle fragment shader as SPIR-V"),
- );
+ let fs_module = device.create_shader_module(wgpu::include_spirv!(
+ "shader/triangle.frag.spv"
+ ));
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
- layout: &layout,
+ label: Some("iced_wgpu::triangle pipeline"),
+ layout: Some(&layout),
vertex_stage: wgpu::ProgrammableStageDescriptor {
module: &vs_module,
entry_point: "main",
@@ -122,9 +147,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 {
@@ -142,28 +165,30 @@ impl Pipeline {
write_mask: wgpu::ColorWrite::ALL,
}],
depth_stencil_state: None,
- index_format: wgpu::IndexFormat::Uint32,
- vertex_buffers: &[wgpu::VertexBufferDescriptor {
- stride: mem::size_of::<Vertex2D>() as u64,
- step_mode: wgpu::InputStepMode::Vertex,
- attributes: &[
- // Position
- wgpu::VertexAttributeDescriptor {
- shader_location: 0,
- format: wgpu::VertexFormat::Float2,
- offset: 0,
- },
- // Color
- wgpu::VertexAttributeDescriptor {
- shader_location: 1,
- format: wgpu::VertexFormat::Float4,
- offset: 4 * 2,
- },
- ],
- }],
- sample_count: antialiasing
- .map(|a| a.sample_count())
- .unwrap_or(1),
+ vertex_state: wgpu::VertexStateDescriptor {
+ index_format: wgpu::IndexFormat::Uint32,
+ vertex_buffers: &[wgpu::VertexBufferDescriptor {
+ stride: mem::size_of::<Vertex2D>() as u64,
+ step_mode: wgpu::InputStepMode::Vertex,
+ attributes: &[
+ // Position
+ wgpu::VertexAttributeDescriptor {
+ shader_location: 0,
+ format: wgpu::VertexFormat::Float2,
+ offset: 0,
+ },
+ // Color
+ wgpu::VertexAttributeDescriptor {
+ shader_location: 1,
+ format: wgpu::VertexFormat::Float4,
+ offset: 4 * 2,
+ },
+ ],
+ }],
+ },
+ sample_count: u32::from(
+ antialiasing.map(|a| a.sample_count()).unwrap_or(1),
+ ),
sample_mask: !0,
alpha_to_coverage_enabled: false,
});
@@ -171,14 +196,17 @@ impl Pipeline {
Pipeline {
pipeline,
blit: antialiasing.map(|a| msaa::Blit::new(device, format, a)),
+ constants_layout,
constants: constant_bind_group,
uniforms_buffer: constants_buffer,
vertex_buffer: Buffer::new(
+ "iced_wgpu::triangle vertex buffer",
device,
VERTEX_BUFFER_SIZE,
wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
),
index_buffer: Buffer::new(
+ "iced_wgpu::triangle index buffer",
device,
INDEX_BUFFER_SIZE,
wgpu::BufferUsage::INDEX | wgpu::BufferUsage::COPY_DST,
@@ -188,30 +216,50 @@ impl Pipeline {
pub fn draw(
&mut self,
- device: &mut wgpu::Device,
+ device: &wgpu::Device,
+ staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder,
target: &wgpu::TextureView,
target_width: u32,
target_height: u32,
transformation: Transformation,
- meshes: &[(Point, &Mesh2D)],
- bounds: Rectangle<u32>,
+ scale_factor: f32,
+ meshes: &[layer::Mesh<'_>],
) {
// This looks a bit crazy, but we are just counting how many vertices
// and indices we will need to handle.
// TODO: Improve readability
let (total_vertices, total_indices) = meshes
.iter()
- .map(|(_, mesh)| (mesh.vertices.len(), mesh.indices.len()))
+ .map(|layer::Mesh { buffers, .. }| {
+ (buffers.vertices.len(), buffers.indices.len())
+ })
.fold((0, 0), |(total_v, total_i), (v, i)| {
(total_v + v, total_i + i)
});
// Then we ensure the current buffers are big enough, resizing if
// necessary
- self.uniforms_buffer.ensure_capacity(device, meshes.len());
- self.vertex_buffer.ensure_capacity(device, total_vertices);
- self.index_buffer.ensure_capacity(device, total_indices);
+ let _ = self.vertex_buffer.expand(device, total_vertices);
+ let _ = self.index_buffer.expand(device, total_indices);
+
+ // If the uniforms buffer is resized, then we need to recreate its
+ // bind group.
+ if self.uniforms_buffer.expand(device, meshes.len()) {
+ self.constants =
+ device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: Some("iced_wgpu::triangle uniforms buffer"),
+ layout: &self.constants_layout,
+ entries: &[wgpu::BindGroupEntry {
+ binding: 0,
+ resource: wgpu::BindingResource::Buffer(
+ self.uniforms_buffer.raw.slice(
+ 0..std::mem::size_of::<Uniforms>() as u64,
+ ),
+ ),
+ }],
+ });
+ }
let mut uniforms: Vec<Uniforms> = Vec::with_capacity(meshes.len());
let mut offsets: Vec<(
@@ -223,73 +271,85 @@ impl Pipeline {
let mut last_index = 0;
// We upload everything upfront
- for (origin, mesh) in meshes {
- let transform = Uniforms {
- transform: (transformation
- * Transformation::translate(origin.x, origin.y))
- .into(),
- };
-
- let vertex_buffer = device
- .create_buffer_mapped(
- mesh.vertices.len(),
- wgpu::BufferUsage::COPY_SRC,
- )
- .fill_from_slice(&mesh.vertices);
-
- let index_buffer = device
- .create_buffer_mapped(
- mesh.indices.len(),
- wgpu::BufferUsage::COPY_SRC,
- )
- .fill_from_slice(&mesh.indices);
-
- encoder.copy_buffer_to_buffer(
- &vertex_buffer,
- 0,
- &self.vertex_buffer.raw,
- (std::mem::size_of::<Vertex2D>() * last_vertex) as u64,
- (std::mem::size_of::<Vertex2D>() * mesh.vertices.len()) as u64,
- );
+ for mesh in meshes {
+ let transform = (transformation
+ * Transformation::translate(mesh.origin.x, mesh.origin.y))
+ .into();
+
+ let vertices = bytemuck::cast_slice(&mesh.buffers.vertices);
+ let indices = bytemuck::cast_slice(&mesh.buffers.indices);
+
+ match (
+ wgpu::BufferSize::new(vertices.len() as u64),
+ wgpu::BufferSize::new(indices.len() as u64),
+ ) {
+ (Some(vertices_size), Some(indices_size)) => {
+ {
+ let mut vertex_buffer = staging_belt.write_buffer(
+ encoder,
+ &self.vertex_buffer.raw,
+ (std::mem::size_of::<Vertex2D>() * last_vertex)
+ as u64,
+ vertices_size,
+ device,
+ );
+
+ vertex_buffer.copy_from_slice(vertices);
+ }
+
+ {
+ let mut index_buffer = staging_belt.write_buffer(
+ encoder,
+ &self.index_buffer.raw,
+ (std::mem::size_of::<u32>() * last_index) as u64,
+ indices_size,
+ device,
+ );
+
+ index_buffer.copy_from_slice(indices);
+ }
+
+ uniforms.push(transform);
+ offsets.push((
+ last_vertex as u64,
+ last_index as u64,
+ mesh.buffers.indices.len(),
+ ));
+
+ last_vertex += mesh.buffers.vertices.len();
+ last_index += mesh.buffers.indices.len();
+ }
+ _ => {}
+ }
+ }
+
+ let uniforms = bytemuck::cast_slice(&uniforms);
- encoder.copy_buffer_to_buffer(
- &index_buffer,
+ if let Some(uniforms_size) =
+ wgpu::BufferSize::new(uniforms.len() as u64)
+ {
+ let mut uniforms_buffer = staging_belt.write_buffer(
+ encoder,
+ &self.uniforms_buffer.raw,
0,
- &self.index_buffer.raw,
- (std::mem::size_of::<u32>() * last_index) as u64,
- (std::mem::size_of::<u32>() * mesh.indices.len()) as u64,
+ uniforms_size,
+ device,
);
- uniforms.push(transform);
- offsets.push((
- last_vertex as u64,
- last_index as u64,
- mesh.indices.len(),
- ));
-
- last_vertex += mesh.vertices.len();
- last_index += mesh.indices.len();
+ uniforms_buffer.copy_from_slice(uniforms);
}
- let uniforms_buffer = device
- .create_buffer_mapped(uniforms.len(), wgpu::BufferUsage::COPY_SRC)
- .fill_from_slice(&uniforms);
-
- encoder.copy_buffer_to_buffer(
- &uniforms_buffer,
- 0,
- &self.uniforms_buffer.raw,
- 0,
- (std::mem::size_of::<Uniforms>() * uniforms.len()) as u64,
- );
-
{
- let (attachment, resolve_target, load_op) =
+ let (attachment, resolve_target, load) =
if let Some(blit) = &mut self.blit {
let (attachment, resolve_target) =
blit.targets(device, target_width, target_height);
- (attachment, Some(resolve_target), wgpu::LoadOp::Clear)
+ (
+ attachment,
+ Some(resolve_target),
+ wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+ )
} else {
(target, None, wgpu::LoadOp::Load)
};
@@ -300,47 +360,43 @@ impl Pipeline {
wgpu::RenderPassColorAttachmentDescriptor {
attachment,
resolve_target,
- load_op,
- 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, store: true },
},
],
depth_stencil_attachment: None,
});
render_pass.set_pipeline(&self.pipeline);
- render_pass.set_scissor_rect(
- bounds.x,
- bounds.y,
- bounds.width,
- bounds.height,
- );
for (i, (vertex_offset, index_offset, indices)) in
offsets.into_iter().enumerate()
{
+ let clip_bounds = (meshes[i].clip_bounds * scale_factor).snap();
+
+ render_pass.set_scissor_rect(
+ clip_bounds.x,
+ clip_bounds.y,
+ clip_bounds.width,
+ clip_bounds.height,
+ );
+
render_pass.set_bind_group(
0,
&self.constants,
- &[(std::mem::size_of::<Uniforms>() * i) as u64],
+ &[(std::mem::size_of::<Uniforms>() * i) as u32],
);
render_pass.set_index_buffer(
- &self.index_buffer.raw,
- index_offset * std::mem::size_of::<u32>() as u64,
+ self.index_buffer
+ .raw
+ .slice(index_offset * mem::size_of::<u32>() as u64..),
);
- render_pass.set_vertex_buffers(
+ render_pass.set_vertex_buffer(
0,
- &[(
- &self.vertex_buffer.raw,
- vertex_offset * std::mem::size_of::<Vertex2D>() as u64,
- )],
+ self.vertex_buffer.raw.slice(
+ vertex_offset * mem::size_of::<Vertex2D>() as u64..,
+ ),
);
render_pass.draw_indexed(0..indices as u32, 0, 0..1);
@@ -354,38 +410,31 @@ impl Pipeline {
}
#[repr(C)]
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Zeroable, Pod)]
struct Uniforms {
transform: [f32; 16],
+ // We need to align this to 256 bytes to please `wgpu`...
+ // TODO: Be smarter and stop wasting memory!
+ _padding_a: [f32; 32],
+ _padding_b: [f32; 16],
}
impl Default for Uniforms {
fn default() -> Self {
Self {
transform: *Transformation::identity().as_ref(),
+ _padding_a: [0.0; 32],
+ _padding_b: [0.0; 16],
}
}
}
-/// A two-dimensional vertex with some color in __linear__ RGBA.
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-pub struct Vertex2D {
- /// The vertex position
- pub position: [f32; 2],
- /// The vertex color in __linear__ RGBA.
- pub color: [f32; 4],
-}
-
-/// A set of [`Vertex2D`] and indices representing a list of triangles.
-///
-/// [`Vertex2D`]: struct.Vertex2D.html
-#[derive(Clone, Debug)]
-pub struct Mesh2D {
- /// The vertices of the mesh
- pub vertices: Vec<Vertex2D>,
- /// The list of vertex indices that defines the triangles of the mesh.
- ///
- /// Therefore, this list should always have a length that is a multiple of 3.
- pub indices: Vec<u32>,
+impl From<Transformation> for Uniforms {
+ fn from(transformation: Transformation) -> Uniforms {
+ Self {
+ transform: transformation.into(),
+ _padding_a: [0.0; 32],
+ _padding_b: [0.0; 16],
+ }
+ }
}
generated by cgit (git 2.34.1) at 2025-05-20 22:28:43 +0000