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.rs605
1 files changed, 242 insertions, 363 deletions
diff --git a/wgpu/src/triangle.rs b/wgpu/src/triangle.rs
index fd06dddf..d632c26c 100644
--- a/wgpu/src/triangle.rs
+++ b/wgpu/src/triangle.rs
@@ -1,429 +1,308 @@
//! Draw meshes of triangles.
use crate::{settings, Transformation};
-use iced_graphics::layer;
+use core::fmt;
+use std::fmt::Formatter;
-use bytemuck::{Pod, Zeroable};
-use std::mem;
+use iced_graphics::layer::Meshes;
+use iced_graphics::shader::Shader;
+use iced_graphics::Size;
+use crate::buffers::buffer::{needs_recreate, StaticBuffer};
+use crate::triangle::gradient::GradientPipeline;
+use crate::triangle::solid::SolidPipeline;
pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
+mod gradient;
mod msaa;
+mod solid;
-const UNIFORM_BUFFER_SIZE: usize = 50;
-const VERTEX_BUFFER_SIZE: usize = 10_000;
-const INDEX_BUFFER_SIZE: usize = 10_000;
-
+/// Triangle pipeline for all mesh layers in a [`iced_graphics::Canvas`] widget.
#[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>,
- index_buffer: Buffer<u32>,
+ // these are optional so we don't allocate any memory to the GPU if
+ // application has no triangle meshes.
+ vertex_buffer: Option<StaticBuffer>,
+ index_buffer: Option<StaticBuffer>,
+ pipelines: TrianglePipelines,
}
-#[derive(Debug)]
-struct Buffer<T> {
- label: &'static str,
- raw: wgpu::Buffer,
- size: usize,
- usage: wgpu::BufferUsages,
- _type: std::marker::PhantomData<T>,
+/// Supported triangle pipelines for different fills. Both use the same vertex shader.
+pub(crate) struct TrianglePipelines {
+ solid: SolidPipeline,
+ gradient: GradientPipeline,
}
-impl<T> Buffer<T> {
- pub fn new(
- label: &'static str,
- device: &wgpu::Device,
- size: usize,
- usage: wgpu::BufferUsages,
- ) -> 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,
- _type: std::marker::PhantomData,
- }
+impl fmt::Debug for TrianglePipelines {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ f.debug_struct("TrianglePipelines").finish()
}
+}
- 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;
- }
+impl TrianglePipelines {
+ /// Resets each pipeline's buffers.
+ fn clear(&mut self) {
+ self.solid.buffer.clear();
+ self.gradient.uniform_buffer.clear();
+ self.gradient.storage_buffer.clear();
+ }
- needs_resize
+ /// Writes the contents of each pipeline's CPU buffer to the GPU, resizing the GPU buffer
+ /// beforehand if necessary.
+ fn write(
+ &mut self,
+ device: &wgpu::Device,
+ staging_belt: &mut wgpu::util::StagingBelt,
+ encoder: &mut wgpu::CommandEncoder,
+ ) {
+ self.solid.write(device, staging_belt, encoder);
+ self.gradient.write(device, staging_belt, encoder);
}
}
impl Pipeline {
+ /// Creates supported GL programs, listed in [TrianglePipelines].
pub fn new(
device: &wgpu::Device,
format: wgpu::TextureFormat,
antialiasing: Option<settings::Antialiasing>,
) -> Pipeline {
- let constants_layout =
- device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
- label: Some("iced_wgpu::triangle uniforms layout"),
- entries: &[wgpu::BindGroupLayoutEntry {
- binding: 0,
- visibility: wgpu::ShaderStages::VERTEX,
- ty: wgpu::BindingType::Buffer {
- ty: wgpu::BufferBindingType::Uniform,
- has_dynamic_offset: 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::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
- );
-
- let constant_bind_group =
- device.create_bind_group(&wgpu::BindGroupDescriptor {
- label: Some("iced_wgpu::triangle uniforms bind group"),
- layout: &constants_layout,
- entries: &[wgpu::BindGroupEntry {
- binding: 0,
- resource: wgpu::BindingResource::Buffer(
- wgpu::BufferBinding {
- buffer: &constants_buffer.raw,
- offset: 0,
- size: wgpu::BufferSize::new(std::mem::size_of::<
- Uniforms,
- >(
- )
- as u64),
- },
- ),
- }],
- });
-
- let layout =
- device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
- label: Some("iced_wgpu::triangle pipeline layout"),
- push_constant_ranges: &[],
- bind_group_layouts: &[&constants_layout],
- });
-
- let shader =
- device.create_shader_module(wgpu::ShaderModuleDescriptor {
- label: Some("iced_wgpu::triangle::shader"),
- source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
- include_str!("shader/triangle.wgsl"),
- )),
- });
-
- let pipeline =
- device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
- label: Some("iced_wgpu::triangle pipeline"),
- layout: Some(&layout),
- vertex: wgpu::VertexState {
- module: &shader,
- entry_point: "vs_main",
- buffers: &[wgpu::VertexBufferLayout {
- array_stride: mem::size_of::<Vertex2D>() as u64,
- step_mode: wgpu::VertexStepMode::Vertex,
- attributes: &wgpu::vertex_attr_array!(
- // Position
- 0 => Float32x2,
- // Color
- 1 => Float32x4,
- ),
- }],
- },
- fragment: Some(wgpu::FragmentState {
- module: &shader,
- entry_point: "fs_main",
- targets: &[Some(wgpu::ColorTargetState {
- format,
- blend: Some(wgpu::BlendState::ALPHA_BLENDING),
- write_mask: wgpu::ColorWrites::ALL,
- })],
- }),
- primitive: wgpu::PrimitiveState {
- topology: wgpu::PrimitiveTopology::TriangleList,
- front_face: wgpu::FrontFace::Cw,
- ..Default::default()
- },
- depth_stencil: None,
- multisample: wgpu::MultisampleState {
- count: antialiasing.map(|a| a.sample_count()).unwrap_or(1),
- mask: !0,
- alpha_to_coverage_enabled: false,
- },
- multiview: None,
- });
-
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::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
- ),
- index_buffer: Buffer::new(
- "iced_wgpu::triangle index buffer",
- device,
- INDEX_BUFFER_SIZE,
- wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
- ),
+ vertex_buffer: None,
+ index_buffer: None,
+ pipelines: TrianglePipelines {
+ solid: SolidPipeline::new(device, format, antialiasing),
+ gradient: GradientPipeline::new(device, format, antialiasing),
+ },
}
}
+ /// Draws the contents of the current layer's meshes to the [target].
pub fn draw(
&mut self,
device: &wgpu::Device,
staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder,
target: &wgpu::TextureView,
- target_width: u32,
- target_height: u32,
+ target_size: Size<u32>,
transformation: Transformation,
scale_factor: f32,
- meshes: &[layer::Mesh<'_>],
+ meshes: &Meshes<'_>,
) {
- // 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(|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
- 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(
- wgpu::BufferBinding {
- buffer: &self.uniforms_buffer.raw,
- offset: 0,
- size: wgpu::BufferSize::new(
- std::mem::size_of::<Uniforms>() as u64,
- ),
- },
- ),
- }],
- });
+ //count the total number of vertices & indices we need to handle
+ let (total_vertices, total_indices) = meshes.attribute_count();
+ println!("total vertices: {}, total indices: {}", total_vertices, total_indices);
+
+ //Only create buffers if they need to be re-sized or don't exist
+ if needs_recreate(&self.vertex_buffer, total_vertices) {
+ //mapped to GPU at creation with total vertices
+ self.vertex_buffer = Some(StaticBuffer::new(
+ device,
+ "iced_wgpu::triangle vertex buffer",
+ //TODO: a more reasonable default to prevent frequent resizing calls
+ // before this was 10_000
+ (std::mem::size_of::<Vertex2D>() * total_vertices) as u64,
+ wgpu::BufferUsages::VERTEX,
+ meshes.0.len(),
+ ))
}
- let mut uniforms: Vec<Uniforms> = Vec::with_capacity(meshes.len());
- let mut offsets: Vec<(
- wgpu::BufferAddress,
- wgpu::BufferAddress,
- usize,
- )> = Vec::with_capacity(meshes.len());
- let mut last_vertex = 0;
- let mut last_index = 0;
-
- // We upload everything upfront
- 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);
-
- if let (Some(vertices_size), Some(indices_size)) = (
- wgpu::BufferSize::new(vertices.len() as u64),
- wgpu::BufferSize::new(indices.len() as u64),
- ) {
- {
- 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,
- );
+ if needs_recreate(&self.index_buffer, total_indices) {
+ //mapped to GPU at creation with total indices
+ self.index_buffer = Some(StaticBuffer::new(
+ device,
+ "iced_wgpu::triangle index buffer",
+ //TODO: a more reasonable default to prevent frequent resizing calls
+ // before this was 10_000
+ (std::mem::size_of::<Vertex2D>() * total_indices) as u64,
+ wgpu::BufferUsages::INDEX,
+ meshes.0.len(),
+ ));
+ }
- vertex_buffer.copy_from_slice(vertices);
+ if let Some(vertex_buffer) = &mut self.vertex_buffer {
+ if let Some(index_buffer) = &mut self.index_buffer {
+ let mut offset_v = 0;
+ let mut offset_i = 0;
+ //TODO: store this more efficiently
+ let mut indices_lengths = Vec::with_capacity(meshes.0.len());
+
+ //iterate through meshes to write all attribute data
+ for mesh in meshes.0.iter() {
+ let transform = transformation
+ * Transformation::translate(
+ mesh.origin.x,
+ mesh.origin.y,
+ );
+
+ println!("Mesh attribute data: Vertex: {:?}, Index: {:?}", mesh.buffers.vertices, mesh.buffers.indices);
+
+ let vertices = bytemuck::cast_slice(&mesh.buffers.vertices);
+ let indices = bytemuck::cast_slice(&mesh.buffers.indices);
+
+ //TODO: it's (probably) more efficient to reduce this write command and
+ // iterate first and then upload
+ println!("vertex buffer len: {}, index length: {}", vertices.len(), indices.len());
+ vertex_buffer.write(offset_v, vertices);
+ index_buffer.write(offset_i, indices);
+
+ offset_v += vertices.len() as u64;
+ offset_i += indices.len() as u64;
+ indices_lengths.push(mesh.buffers.indices.len());
+
+ match mesh.shader {
+ Shader::Solid(color) => {
+ self.pipelines.solid.push(transform, color);
+ }
+ Shader::Gradient(gradient) => {
+ self.pipelines.gradient.push(transform, gradient);
+ }
+ }
}
+ //done writing to gpu buffer, unmap from host memory since we don't need it
+ //anymore
+ vertex_buffer.flush();
+ index_buffer.flush();
+
+ //resize & memcpy uniforms from CPU buffers to GPU buffers for all pipelines
+ self.pipelines.write(device, staging_belt, encoder);
+
+ //configure the render pass now that the data is uploaded to the GPU
{
- 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,
+ //configure antialiasing pass
+ let (attachment, resolve_target, load) =
+ if let Some(blit) = &mut self.blit {
+ let (attachment, resolve_target) = blit.targets(
+ device,
+ target_size.width,
+ target_size.height,
+ );
+
+ (
+ attachment,
+ Some(resolve_target),
+ wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+ )
+ } else {
+ (target, None, wgpu::LoadOp::Load)
+ };
+
+ let mut render_pass = encoder.begin_render_pass(
+ &wgpu::RenderPassDescriptor {
+ label: Some("iced_wgpu::triangle render pass"),
+ color_attachments: &[Some(
+ wgpu::RenderPassColorAttachment {
+ view: attachment,
+ resolve_target,
+ ops: wgpu::Operations { load, store: true },
+ },
+ )],
+ depth_stencil_attachment: None,
+ },
);
- index_buffer.copy_from_slice(indices);
+ //TODO: do this a better way; store it in the respective pipelines perhaps
+ // to be more readable
+ let mut num_solids = 0;
+ let mut num_gradients = 0;
+
+ //TODO: try to avoid this extra iteration if possible
+ for index in 0..meshes.0.len() {
+ let clip_bounds =
+ (meshes.0[index].clip_bounds * scale_factor).snap();
+
+ render_pass.set_scissor_rect(
+ clip_bounds.x,
+ clip_bounds.y,
+ clip_bounds.width,
+ clip_bounds.height,
+ );
+
+ match meshes.0[index].shader {
+ Shader::Solid(_) => {
+ self.pipelines.solid.configure_render_pass(
+ &mut render_pass,
+ num_solids,
+ );
+ num_solids += 1;
+ }
+ Shader::Gradient(_) => {
+ self.pipelines.gradient.configure_render_pass(
+ &mut render_pass,
+ num_gradients,
+ );
+ num_gradients += 1;
+ }
+ }
+
+ render_pass.set_index_buffer(
+ index_buffer.slice_from_index::<u32>(index),
+ wgpu::IndexFormat::Uint32,
+ );
+
+ render_pass.set_vertex_buffer(
+ 0,
+ vertex_buffer.slice_from_index::<Vertex2D>(index),
+ );
+
+ render_pass.draw_indexed(
+ 0..(indices_lengths[index] as u32),
+ 0,
+ 0..1,
+ );
+ }
}
-
- 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);
-
- 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,
- uniforms_size,
- device,
- );
-
- uniforms_buffer.copy_from_slice(uniforms);
- }
-
- {
- 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(wgpu::Color::TRANSPARENT),
- )
- } else {
- (target, None, wgpu::LoadOp::Load)
- };
-
- let mut render_pass =
- encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
- label: Some("iced_wgpu::triangle render pass"),
- color_attachments: &[Some(
- wgpu::RenderPassColorAttachment {
- view: attachment,
- resolve_target,
- ops: wgpu::Operations { load, store: true },
- },
- )],
- depth_stencil_attachment: None,
- });
-
- render_pass.set_pipeline(&self.pipeline);
-
- 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 u32],
- );
-
- render_pass.set_index_buffer(
- self.index_buffer
- .raw
- .slice(index_offset * mem::size_of::<u32>() as u64..),
- wgpu::IndexFormat::Uint32,
- );
-
- render_pass.set_vertex_buffer(
- 0,
- self.vertex_buffer.raw.slice(
- vertex_offset * mem::size_of::<Vertex2D>() as u64..,
- ),
- );
-
- render_pass.draw_indexed(0..indices as u32, 0, 0..1);
}
}
if let Some(blit) = &mut self.blit {
blit.draw(encoder, target);
}
+
+ //cleanup
+ self.pipelines.clear();
}
}
-#[repr(C)]
-#[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],
+//utility functions for individual pipelines with shared functionality
+fn vertex_buffer_layout<'a>() -> wgpu::VertexBufferLayout<'a> {
+ wgpu::VertexBufferLayout {
+ array_stride: std::mem::size_of::<Vertex2D>() as u64,
+ step_mode: wgpu::VertexStepMode::Vertex,
+ attributes: &[wgpu::VertexAttribute {
+ format: wgpu::VertexFormat::Float32x2,
+ offset: 0,
+ shader_location: 0,
+ }],
+ }
}
-impl Default for Uniforms {
- fn default() -> Self {
- Self {
- transform: *Transformation::identity().as_ref(),
- _padding_a: [0.0; 32],
- _padding_b: [0.0; 16],
- }
+fn default_fragment_target(
+ texture_format: wgpu::TextureFormat,
+) -> Option<wgpu::ColorTargetState> {
+ Some(wgpu::ColorTargetState {
+ format: texture_format,
+ blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+ write_mask: wgpu::ColorWrites::ALL,
+ })
+}
+
+fn default_triangle_primitive_state() -> wgpu::PrimitiveState {
+ wgpu::PrimitiveState {
+ topology: wgpu::PrimitiveTopology::TriangleList,
+ front_face: wgpu::FrontFace::Cw,
+ ..Default::default()
}
}
-impl From<Transformation> for Uniforms {
- fn from(transformation: Transformation) -> Uniforms {
- Self {
- transform: transformation.into(),
- _padding_a: [0.0; 32],
- _padding_b: [0.0; 16],
- }
+fn default_multisample_state(
+ antialiasing: Option<settings::Antialiasing>,
+) -> wgpu::MultisampleState {
+ wgpu::MultisampleState {
+ count: antialiasing.map(|a| a.sample_count()).unwrap_or(1),
+ mask: !0,
+ alpha_to_coverage_enabled: false,
}
}
generated by cgit (git 2.34.1) at 2025-04-15 05:23:55 +0000