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

Compute vertex position in shader

Browse source
This commit is contained in:
Jim Eckerlein 2023-09-24 15:10:19 +02:00
parent bc9bb28b1c
commit 3f467d1212
6 changed files with 60 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

61
wgpu/src/quad.rs
View file

@ -9,7 +9,6 @@ use crate::graphics::color;
use crate::graphics::{self, Transformation}; use crate::graphics::{self, Transformation};
use bytemuck::{Pod, Zeroable}; use bytemuck::{Pod, Zeroable};
use wgpu::util::DeviceExt;
use std::mem; use std::mem;
@ -23,8 +22,6 @@ pub struct Pipeline {
solid: solid::Pipeline, solid: solid::Pipeline,
gradient: gradient::Pipeline, gradient: gradient::Pipeline,
constant_layout: wgpu::BindGroupLayout, constant_layout: wgpu::BindGroupLayout,
vertices: wgpu::Buffer,
indices: wgpu::Buffer,
layers: Vec<Layer>, layers: Vec<Layer>,
prepare_layer: usize, prepare_layer: usize,
} }
@ -48,23 +45,7 @@ impl Pipeline {
}], }],
}); });
let vertices =
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("iced_wgpu::quad vertex buffer"),
contents: bytemuck::cast_slice(&VERTICES),
usage: wgpu::BufferUsages::VERTEX,
});
let indices =
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("iced_wgpu::quad index buffer"),
contents: bytemuck::cast_slice(&INDICES),
usage: wgpu::BufferUsages::INDEX,
});
Self { Self {
vertices,
indices,
solid: solid::Pipeline::new(device, format, &constant_layout), solid: solid::Pipeline::new(device, format, &constant_layout),
gradient: gradient::Pipeline::new(device, format, &constant_layout), gradient: gradient::Pipeline::new(device, format, &constant_layout),
layers: Vec::new(), layers: Vec::new(),
@ -105,11 +86,6 @@ impl Pipeline {
bounds.width, bounds.width,
bounds.height, bounds.height,
); );
render_pass.set_index_buffer(
self.indices.slice(..),
wgpu::IndexFormat::Uint16,
);
render_pass.set_vertex_buffer(0, self.vertices.slice(..));
let mut solid_offset = 0; let mut solid_offset = 0;
let mut gradient_offset = 0; let mut gradient_offset = 0;
@ -311,43 +287,6 @@ fn color_target_state(
})] })]
} }
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Zeroable, bytemuck::Pod)]
pub struct Vertex {
_position: [f32; 2],
}
impl Vertex {
fn buffer_layout<'a>() -> wgpu::VertexBufferLayout<'a> {
wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Self>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &[wgpu::VertexAttribute {
shader_location: 0,
format: wgpu::VertexFormat::Float32x2,
offset: 0,
}],
}
}
}
const INDICES: [u16; 6] = [0, 1, 2, 0, 2, 3];
const VERTICES: [Vertex; 4] = [
Vertex {
_position: [0.0, 0.0],
},
Vertex {
_position: [1.0, 0.0],
},
Vertex {
_position: [1.0, 1.0],
},
Vertex {
_position: [0.0, 1.0],
},
];
#[repr(C)] #[repr(C)]
#[derive(Debug, Clone, Copy, bytemuck::Zeroable, bytemuck::Pod)] #[derive(Debug, Clone, Copy, bytemuck::Zeroable, bytemuck::Pod)]
struct Uniforms { struct Uniforms {

64
wgpu/src/quad/gradient.rs
View file

@ -106,36 +106,32 @@ impl Pipeline {
vertex: wgpu::VertexState { vertex: wgpu::VertexState {
module: &shader, module: &shader,
entry_point: "gradient_vs_main", entry_point: "gradient_vs_main",
buffers: &[ buffers: &[wgpu::VertexBufferLayout {
quad::Vertex::buffer_layout(), array_stride: std::mem::size_of::<Gradient>() as u64,
wgpu::VertexBufferLayout { step_mode: wgpu::VertexStepMode::Instance,
array_stride: std::mem::size_of::<Gradient>() attributes: &wgpu::vertex_attr_array!(
as u64, // Colors 1-2
step_mode: wgpu::VertexStepMode::Instance, 1 => Uint32x4,
attributes: &wgpu::vertex_attr_array!( // Colors 3-4
// Colors 1-2 2 => Uint32x4,
1 => Uint32x4, // Colors 5-6
// Colors 3-4 3 => Uint32x4,
2 => Uint32x4, // Colors 7-8
// Colors 5-6 4 => Uint32x4,
3 => Uint32x4, // Offsets 1-8
// Colors 7-8 5 => Uint32x4,
4 => Uint32x4, // Direction
// Offsets 1-8 6 => Float32x4,
5 => Uint32x4, // Position & Scale
// Direction 7 => Float32x4,
6 => Float32x4, // Border color
// Position & Scale 8 => Float32x4,
7 => Float32x4, // Border radius
// Border color 9 => Float32x4,
8 => Float32x4, // Border width
// Border radius 10 => Float32
9 => Float32x4, ),
// Border width }],
10 => Float32
),
},
],
}, },
fragment: Some(wgpu::FragmentState { fragment: Some(wgpu::FragmentState {
module: &shader, module: &shader,
@ -171,12 +167,8 @@ impl Pipeline {
render_pass.set_pipeline(&self.pipeline); render_pass.set_pipeline(&self.pipeline);
render_pass.set_bind_group(0, constants, &[]); render_pass.set_bind_group(0, constants, &[]);
render_pass.set_vertex_buffer(1, layer.instances.slice(..)); render_pass.set_vertex_buffer(0, layer.instances.slice(..));
render_pass.draw_indexed( render_pass.draw(0..6, range.start as u32..range.end as u32);
0..quad::INDICES.len() as u32,
0,
range.start as u32..range.end as u32,
);
} }
} }

47
wgpu/src/quad/solid.rs
View file

@ -87,27 +87,24 @@ impl Pipeline {
vertex: wgpu::VertexState { vertex: wgpu::VertexState {
module: &shader, module: &shader,
entry_point: "solid_vs_main", entry_point: "solid_vs_main",
buffers: &[ buffers: &[wgpu::VertexBufferLayout {
quad::Vertex::buffer_layout(), array_stride: std::mem::size_of::<Solid>() as u64,
wgpu::VertexBufferLayout { step_mode: wgpu::VertexStepMode::Instance,
array_stride: std::mem::size_of::<Solid>() as u64, attributes: &wgpu::vertex_attr_array!(
step_mode: wgpu::VertexStepMode::Instance, // Color
attributes: &wgpu::vertex_attr_array!( 1 => Float32x4,
// Color // Position
1 => Float32x4, 2 => Float32x2,
// Position // Size
2 => Float32x2, 3 => Float32x2,
// Size // Border color
3 => Float32x2, 4 => Float32x4,
// Border color // Border radius
4 => Float32x4, 5 => Float32x4,
// Border radius // Border width
5 => Float32x4, 6 => Float32,
// Border width ),
6 => Float32, }],
),
},
],
}, },
fragment: Some(wgpu::FragmentState { fragment: Some(wgpu::FragmentState {
module: &shader, module: &shader,
@ -143,12 +140,8 @@ impl Pipeline {
render_pass.set_pipeline(&self.pipeline); render_pass.set_pipeline(&self.pipeline);
render_pass.set_bind_group(0, constants, &[]); render_pass.set_bind_group(0, constants, &[]);
render_pass.set_vertex_buffer(1, layer.instances.slice(..)); render_pass.set_vertex_buffer(0, layer.instances.slice(..));
render_pass.draw_indexed( render_pass.draw(0..6, range.start as u32..range.end as u32);
0..quad::INDICES.len() as u32,
0,
range.start as u32..range.end as u32,
);
} }
} }

8
wgpu/src/shader/quad.wgsl
View file

@ -37,3 +37,11 @@ fn select_border_radius(radi: vec4<f32>, position: vec2<f32>, center: vec2<f32>)
rx = select(rx, ry, position.y > center.y); rx = select(rx, ry, position.y > center.y);
return rx; return rx;
} }
// Compute the normalized quad coordinates based on the vertex index.
fn vertex_position(vertex_index: u32) -> vec2<f32> {
// #: 0 1 2 3 4 5
// x: 1 1 0 0 0 1
// y: 1 0 0 0 1 1
return vec2<f32>((vec2(1u, 2u) + vertex_index) % 6u < 3u);
}

4
wgpu/src/shader/quad/gradient.wgsl
View file

@ -1,5 +1,5 @@
struct GradientVertexInput { struct GradientVertexInput {
@location(0) v_pos: vec2<f32>, @builtin(vertex_index) vertex_index: u32,
@location(1) @interpolate(flat) colors_1: vec4<u32>, @location(1) @interpolate(flat) colors_1: vec4<u32>,
@location(2) @interpolate(flat) colors_2: vec4<u32>, @location(2) @interpolate(flat) colors_2: vec4<u32>,
@location(3) @interpolate(flat) colors_3: vec4<u32>, @location(3) @interpolate(flat) colors_3: vec4<u32>,
@ -48,7 +48,7 @@ fn gradient_vs_main(input: GradientVertexInput) -> GradientVertexOutput {
vec4<f32>(pos - vec2<f32>(0.5, 0.5), 0.0, 1.0) vec4<f32>(pos - vec2<f32>(0.5, 0.5), 0.0, 1.0)
); );
out.position = globals.transform * transform * vec4<f32>(input.v_pos, 0.0, 1.0); out.position = globals.transform * transform * vec4<f32>(vertex_position(input.vertex_index), 0.0, 1.0);
out.colors_1 = input.colors_1; out.colors_1 = input.colors_1;
out.colors_2 = input.colors_2; out.colors_2 = input.colors_2;
out.colors_3 = input.colors_3; out.colors_3 = input.colors_3;

4
wgpu/src/shader/quad/solid.wgsl
View file

@ -1,5 +1,5 @@
struct SolidVertexInput { struct SolidVertexInput {
@location(0) v_pos: vec2<f32>, @builtin(vertex_index) vertex_index: u32,
@location(1) color: vec4<f32>, @location(1) color: vec4<f32>,
@location(2) pos: vec2<f32>, @location(2) pos: vec2<f32>,
@location(3) scale: vec2<f32>, @location(3) scale: vec2<f32>,
@ -40,7 +40,7 @@ fn solid_vs_main(input: SolidVertexInput) -> SolidVertexOutput {
vec4<f32>(pos - vec2<f32>(0.5, 0.5), 0.0, 1.0) vec4<f32>(pos - vec2<f32>(0.5, 0.5), 0.0, 1.0)
); );
out.position = globals.transform * transform * vec4<f32>(input.v_pos, 0.0, 1.0); out.position = globals.transform * transform * vec4<f32>(vertex_position(input.vertex_index), 0.0, 1.0);
out.color = input.color; out.color = input.color;
out.border_color = input.border_color; out.border_color = input.border_color;
out.pos = pos; out.pos = pos;