Adds linear gradient support to 2D meshes in the canvas widget.
This commit is contained in:
shan
parent
97f385e093
commit
40f45d7b7e
40 changed files with 2041 additions and 655 deletions
|
|
@ -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,
|
||||
});
|
||||
impl fmt::Debug for TrianglePipelines {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("TrianglePipelines").finish()
|
||||
}
|
||||
}
|
||||
|
||||
Buffer {
|
||||
label,
|
||||
raw,
|
||||
size,
|
||||
usage,
|
||||
_type: std::marker::PhantomData,
|
||||
}
|
||||
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();
|
||||
}
|
||||
|
||||
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
|
||||
/// 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)
|
||||
});
|
||||
//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);
|
||||
|
||||
// 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,
|
||||
),
|
||||
},
|
||||
),
|
||||
}],
|
||||
});
|
||||
}
|
||||
|
||||
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,
|
||||
);
|
||||
|
||||
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);
|
||||
|
||||
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,
|
||||
//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,
|
||||
);
|
||||
|
||||
uniforms_buffer.copy_from_slice(uniforms);
|
||||
"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 (attachment, resolve_target, load) =
|
||||
if let Some(blit) = &mut self.blit {
|
||||
let (attachment, resolve_target) =
|
||||
blit.targets(device, target_width, target_height);
|
||||
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(),
|
||||
));
|
||||
}
|
||||
|
||||
(
|
||||
attachment,
|
||||
Some(resolve_target),
|
||||
wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
|
||||
)
|
||||
} else {
|
||||
(target, None, wgpu::LoadOp::Load)
|
||||
};
|
||||
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());
|
||||
|
||||
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 },
|
||||
//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
|
||||
{
|
||||
//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,
|
||||
},
|
||||
)],
|
||||
depth_stencil_attachment: None,
|
||||
});
|
||||
);
|
||||
|
||||
render_pass.set_pipeline(&self.pipeline);
|
||||
//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;
|
||||
|
||||
for (i, (vertex_offset, index_offset, indices)) in
|
||||
offsets.into_iter().enumerate()
|
||||
{
|
||||
let clip_bounds = (meshes[i].clip_bounds * scale_factor).snap();
|
||||
//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,
|
||||
);
|
||||
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],
|
||||
);
|
||||
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(
|
||||
self.index_buffer
|
||||
.raw
|
||||
.slice(index_offset * mem::size_of::<u32>() as u64..),
|
||||
wgpu::IndexFormat::Uint32,
|
||||
);
|
||||
render_pass.set_index_buffer(
|
||||
index_buffer.slice_from_index::<u32>(index),
|
||||
wgpu::IndexFormat::Uint32,
|
||||
);
|
||||
|
||||
render_pass.set_vertex_buffer(
|
||||
0,
|
||||
self.vertex_buffer.raw.slice(
|
||||
vertex_offset * mem::size_of::<Vertex2D>() as u64..,
|
||||
),
|
||||
);
|
||||
render_pass.set_vertex_buffer(
|
||||
0,
|
||||
vertex_buffer.slice_from_index::<Vertex2D>(index),
|
||||
);
|
||||
|
||||
render_pass.draw_indexed(0..indices as u32, 0, 0..1);
|
||||
render_pass.draw_indexed(
|
||||
0..(indices_lengths[index] 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],
|
||||
}
|
||||
|
||||
impl Default for Uniforms {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
transform: *Transformation::identity().as_ref(),
|
||||
_padding_a: [0.0; 32],
|
||||
_padding_b: [0.0; 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 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_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()
|
||||
}
|
||||
}
|
||||
|
||||
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,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue