reivilibre/iced-mobile
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Upgrade wgpu

Browse Source
This commit is contained in:
Dispersia 2021-04-11 18:55:57 -07:00
parent 4b8ba8309f
commit 9a2c78c405
28 changed files with 386 additions and 353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
examples/integration/src/scene.rs
View File

@ -20,8 +20,8 @@ impl Scene {
) -> wgpu::RenderPass<'a> {
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: None,
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: target,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: target,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear({
@ -75,15 +75,16 @@ fn build_pipeline(device: &wgpu::Device) -> wgpu::RenderPipeline {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: wgpu::TextureFormat::Bgra8UnormSrgb,
color_blend: wgpu::BlendState::REPLACE,
alpha_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::None,
..Default::default()
},
depth_stencil: None,

4
wgpu/Cargo.toml
View File

@ -26,8 +26,8 @@ qr_code = ["iced_graphics/qr_code"]
default_system_font = ["iced_graphics/font-source"]
[dependencies]
wgpu = "0.7"
wgpu_glyph = "0.11"
wgpu = {git = "https://github.com/gfx-rs/wgpu-rs", rev = "53600ecd834893ef3e90458c48b84f2582d6c343"}
wgpu_glyph = {git = "https://github.com/Dispersia/wgpu_glyph", branch = "update-wgpu"}
glyph_brush = "0.7"
raw-window-handle = "0.3"
log = "0.4"

59
wgpu/src/image.rs
View File

@ -134,28 +134,26 @@ impl Pipeline {
bind_group_layouts: &[&constant_layout, &texture_layout],
});
let vs_module = device.create_shader_module(&wgpu::include_spirv!(
"shader/image.vert.spv"
));
let fs_module = device.create_shader_module(&wgpu::include_spirv!(
"shader/image.frag.spv"
));
let shader = device.create_shader_module(&wgpu::ShaderModuleDescriptor {
label: Some("iced_wgpu::image::shader"),
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(include_str!("shader/image.wgsl"))),
flags: wgpu::ShaderFlags::all()
});
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("iced_wgpu::image pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &vs_module,
entry_point: "main",
module: &shader,
entry_point: "vs_main",
buffers: &[
wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Vertex>() as u64,
step_mode: wgpu::InputStepMode::Vertex,
attributes: &[wgpu::VertexAttribute {
shader_location: 0,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 0,
}],
},
@ -165,27 +163,27 @@ impl Pipeline {
attributes: &[
wgpu::VertexAttribute {
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 0,
},
wgpu::VertexAttribute {
shader_location: 2,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 4 * 2,
},
wgpu::VertexAttribute {
shader_location: 3,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 4 * 4,
},
wgpu::VertexAttribute {
shader_location: 4,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 4 * 6,
},
wgpu::VertexAttribute {
shader_location: 5,
format: wgpu::VertexFormat::Uint,
format: wgpu::VertexFormat::Uint32,
offset: 4 * 8,
},
],
@ -193,27 +191,28 @@ impl Pipeline {
],
},
fragment: Some(wgpu::FragmentState {
module: &fs_module,
entry_point: "main",
module: &shader,
entry_point: "fs_main",
targets: &[wgpu::ColorTargetState {
format,
color_blend: wgpu::BlendState {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha_blend: wgpu::BlendState {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None,
..Default::default()
},
depth_stencil: None,
@ -424,8 +423,8 @@ impl Pipeline {
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("iced_wgpu::image render pass"),
color_attachments: &[
wgpu::RenderPassColorAttachmentDescriptor {
attachment: target,
wgpu::RenderPassColorAttachment {
view: target,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Load,

24
wgpu/src/image/atlas.rs
View File

@ -4,6 +4,8 @@ mod allocation;
mod allocator;
mod layer;
use std::num::NonZeroU32;
pub use allocation::Allocation;
pub use entry::Entry;
pub use layer::Layer;
@ -24,7 +26,7 @@ impl Atlas {
let extent = wgpu::Extent3d {
width: SIZE,
height: SIZE,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
@ -294,19 +296,19 @@ impl Atlas {
let extent = wgpu::Extent3d {
width,
height,
depth: 1,
depth_or_array_layers: 1,
};
encoder.copy_buffer_to_texture(
wgpu::BufferCopyView {
wgpu::ImageCopyBuffer {
buffer,
layout: wgpu::TextureDataLayout {
layout: wgpu::ImageDataLayout {
offset: offset as u64,
bytes_per_row: 4 * image_width + padding,
rows_per_image: image_height,
bytes_per_row: NonZeroU32::new(4 * image_width + padding),
rows_per_image: NonZeroU32::new(image_height),
},
},
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &self.texture,
mip_level: 0,
origin: wgpu::Origin3d {
@ -334,7 +336,7 @@ impl Atlas {
size: wgpu::Extent3d {
width: SIZE,
height: SIZE,
depth: self.layers.len() as u32,
depth_or_array_layers: self.layers.len() as u32,
},
mip_level_count: 1,
sample_count: 1,
@ -355,7 +357,7 @@ impl Atlas {
}
encoder.copy_texture_to_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &self.texture,
mip_level: 0,
origin: wgpu::Origin3d {
@ -364,7 +366,7 @@ impl Atlas {
z: i as u32,
},
},
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &new_texture,
mip_level: 0,
origin: wgpu::Origin3d {
@ -376,7 +378,7 @@ impl Atlas {
wgpu::Extent3d {
width: SIZE,
height: SIZE,
depth: 1,
depth_or_array_layers: 1,
},
);
}

76
wgpu/src/quad.rs
View File

@ -62,28 +62,29 @@ impl Pipeline {
bind_group_layouts: &[&constant_layout],
});
let vs_module = device.create_shader_module(&wgpu::include_spirv!(
"shader/quad.vert.spv"
));
let fs_module = device.create_shader_module(&wgpu::include_spirv!(
"shader/quad.frag.spv"
));
let shader =
device.create_shader_module(&wgpu::ShaderModuleDescriptor {
label: Some("iced_wgpu::quad::shader"),
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
include_str!("shader/quad.wgsl"),
)),
flags: wgpu::ShaderFlags::all(),
});
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("iced_wgpu::quad pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &vs_module,
entry_point: "main",
module: &shader,
entry_point: "vs_main",
buffers: &[
wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Vertex>() as u64,
step_mode: wgpu::InputStepMode::Vertex,
attributes: &[wgpu::VertexAttribute {
shader_location: 0,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 0,
}],
},
@ -93,32 +94,32 @@ impl Pipeline {
attributes: &[
wgpu::VertexAttribute {
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 0,
},
wgpu::VertexAttribute {
shader_location: 2,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 4 * 2,
},
wgpu::VertexAttribute {
shader_location: 3,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
offset: 4 * (2 + 2),
},
wgpu::VertexAttribute {
shader_location: 4,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
offset: 4 * (2 + 2 + 4),
},
wgpu::VertexAttribute {
shader_location: 5,
format: wgpu::VertexFormat::Float,
format: wgpu::VertexFormat::Float32,
offset: 4 * (2 + 2 + 4 + 4),
},
wgpu::VertexAttribute {
shader_location: 6,
format: wgpu::VertexFormat::Float,
format: wgpu::VertexFormat::Float32,
offset: 4 * (2 + 2 + 4 + 4 + 1),
},
],
@ -126,27 +127,28 @@ impl Pipeline {
],
},
fragment: Some(wgpu::FragmentState {
module: &fs_module,
entry_point: "main",
module: &shader,
entry_point: "fs_main",
targets: &[wgpu::ColorTargetState {
format,
color_blend: wgpu::BlendState {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha_blend: wgpu::BlendState {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None,
..Default::default()
},
depth_stencil: None,
@ -237,16 +239,14 @@ impl Pipeline {
let mut render_pass =
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("iced_wgpu::quad render pass"),
color_attachments: &[
wgpu::RenderPassColorAttachmentDescriptor {
attachment: target,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Load,
store: true,
},
color_attachments: &[wgpu::RenderPassColorAttachment {
view: target,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Load,
store: true,
},
],
}],
depth_stencil_attachment: None,
});

12
wgpu/src/shader/blit.frag
View File

@ -1,12 +0,0 @@
#version 450
layout(location = 0) in vec2 v_Uv;
layout(set = 0, binding = 0) uniform sampler u_Sampler;
layout(set = 1, binding = 0) uniform texture2D u_Texture;
layout(location = 0) out vec4 o_Color;
void main() {
o_Color = texture(sampler2D(u_Texture, u_Sampler), v_Uv);
}

BIN
wgpu/src/shader/blit.frag.spv
View File

Binary file not shown.

26
wgpu/src/shader/blit.vert
View File

@ -1,26 +0,0 @@
#version 450
layout(location = 0) out vec2 o_Uv;
const vec2 positions[6] = vec2[6](
vec2(-1.0, 1.0),
vec2(-1.0, -1.0),
vec2(1.0, -1.0),
vec2(-1.0, 1.0),
vec2(1.0, 1.0),
vec2(1.0, -1.0)
);
const vec2 uvs[6] = vec2[6](
vec2(0.0, 0.0),
vec2(0.0, 1.0),
vec2(1.0, 1.0),
vec2(0.0, 0.0),
vec2(1.0, 0.0),
vec2(1.0, 1.0)
);
void main() {
o_Uv = uvs[gl_VertexIndex];
gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
}

BIN
wgpu/src/shader/blit.vert.spv
View File

Binary file not shown.

43
wgpu/src/shader/blit.wgsl Normal file
View File

@ -0,0 +1,43 @@
var positions: array<vec2<f32>, 6> = array<vec2<f32>, 6>(
vec2<f32>(-1.0, 1.0),
vec2<f32>(-1.0, -1.0),
vec2<f32>(1.0, -1.0),
vec2<f32>(-1.0, 1.0),
vec2<f32>(1.0, 1.0),
vec2<f32>(1.0, -1.0)
);
var uvs: array<vec2<f32>, 6> = array<vec2<f32>, 6>(
vec2<f32>(0.0, 0.0),
vec2<f32>(0.0, 1.0),
vec2<f32>(1.0, 1.0),
vec2<f32>(0.0, 0.0),
vec2<f32>(1.0, 0.0),
vec2<f32>(1.0, 1.0)
);
[[group(0), binding(0)]] var u_sampler: sampler;
[[group(1), binding(0)]] var u_texture: texture_2d<f32>;
struct VertexInput {
[[builtin(vertex_index)]] vertex_index: u32;
};
struct VertexOutput {
[[builtin(position)]] position: vec4<f32>;
[[location(0)]] uv: vec2<f32>;
};
[[stage(vertex)]]
fn vs_main(input: VertexInput) -> VertexOutput {
var out: VertexOutput;
out.uv = uvs[input.vertex_index];
out.position = vec4<f32>(positions[input.vertex_index], 0.0, 1.0);
return out;
}
[[stage(fragment)]]
fn fs_main(input: VertexOutput) -> [[location(0)]] vec4<f32> {
return textureSample(u_texture, u_sampler, input.uv);
}

12
wgpu/src/shader/image.frag
View File

@ -1,12 +0,0 @@
#version 450
layout(location = 0) in vec3 v_Uv;
layout(set = 0, binding = 1) uniform sampler u_Sampler;
layout(set = 1, binding = 0) uniform texture2DArray u_Texture;
layout(location = 0) out vec4 o_Color;
void main() {
o_Color = texture(sampler2DArray(u_Texture, u_Sampler), v_Uv);
}

BIN
wgpu/src/shader/image.frag.spv
View File

Binary file not shown.

27
wgpu/src/shader/image.vert
View File

@ -1,27 +0,0 @@
#version 450
layout(location = 0) in vec2 v_Pos;
layout(location = 1) in vec2 i_Pos;
layout(location = 2) in vec2 i_Scale;
layout(location = 3) in vec2 i_Atlas_Pos;
layout(location = 4) in vec2 i_Atlas_Scale;
layout(location = 5) in uint i_Layer;
layout (set = 0, binding = 0) uniform Globals {
mat4 u_Transform;
};
layout(location = 0) out vec3 o_Uv;
void main() {
o_Uv = vec3(v_Pos * i_Atlas_Scale + i_Atlas_Pos, i_Layer);
mat4 i_Transform = mat4(
vec4(i_Scale.x, 0.0, 0.0, 0.0),
vec4(0.0, i_Scale.y, 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
vec4(i_Pos, 0.0, 1.0)
);
gl_Position = u_Transform * i_Transform * vec4(v_Pos, 0.0, 1.0);
}

BIN
wgpu/src/shader/image.vert.spv
View File

Binary file not shown.

45
wgpu/src/shader/image.wgsl Normal file
View File

@ -0,0 +1,45 @@
[[block]]
struct Globals {
transform: mat4x4<f32>;
};
[[group(0), binding(0)]] var<uniform> globals: Globals;
[[group(0), binding(1)]] var u_sampler: sampler;
[[group(0), binding(2)]] var u_texture: texture2d<f32>;
struct VertexInput {
[[location(0)]] v_pos: vec2<f32>;
[[location(1)]] pos: vec2<f32>;
[[location(2)]] scale: vec2<f32>;
[[location(3)]] atlas_pos: vec2<f32>;
[[location(4)]] atlas_scale: vec2<f32>;
[[location(5)]] layer: u32;
};
struct VertexOutput {
[[builtin(position)]] position: vec4<f32>;
[[location(0)]] uv: vec3<f32>;
};
[[stage(vertex)]]
fn vs_main(input: VertexInput) -> VertexOutput {
var out: VertexOutput;
out.uv = vec3<f32>(input.v_pos * input.atlas_scale + input.atlas_pos, input.layer);
var transform: mat4x4<f32> = mat4x4<f32>(
vec4<f32>(input.scale.x, 0.0, 0.0, 0.0),
vec4<f32>(0.0, scale.y, 0.0, 0.0),
vec4<f32>(0.0, 0.0, 1.0, 0.0),
vec4<f32>(input.pos, 0.0, 1.0)
);
out.position = globals.transform * transform * vec4<f32>(input.v_pos, 0.0, 1.0);
return out;
}
[[stage(fragment)]]
fn fs_main(input: VertexOutput) -> [[location(0)]] vec4<f32> {
return textureSample(u_texture, u_sampler, input.uv);
}

66
wgpu/src/shader/quad.frag
View File

@ -1,66 +0,0 @@
#version 450
layout(location = 0) in vec4 v_Color;
layout(location = 1) in vec4 v_BorderColor;
layout(location = 2) in vec2 v_Pos;
layout(location = 3) in vec2 v_Scale;
layout(location = 4) in float v_BorderRadius;
layout(location = 5) in float v_BorderWidth;
layout(location = 0) out vec4 o_Color;
float distance(in vec2 frag_coord, in vec2 position, in vec2 size, float radius)
{
// TODO: Try SDF approach: https://www.shadertoy.com/view/wd3XRN
vec2 inner_size = size - vec2(radius, radius) * 2.0;
vec2 top_left = position + vec2(radius, radius);
vec2 bottom_right = top_left + inner_size;
vec2 top_left_distance = top_left - frag_coord;
vec2 bottom_right_distance = frag_coord - bottom_right;
vec2 distance = vec2(
max(max(top_left_distance.x, bottom_right_distance.x), 0),
max(max(top_left_distance.y, bottom_right_distance.y), 0)
);
return sqrt(distance.x * distance.x + distance.y * distance.y);
}
void main() {
vec4 mixed_color;
// TODO: Remove branching (?)
if(v_BorderWidth > 0) {
float internal_border = max(v_BorderRadius - v_BorderWidth, 0);
float internal_distance = distance(
gl_FragCoord.xy,
v_Pos + vec2(v_BorderWidth),
v_Scale - vec2(v_BorderWidth * 2.0),
internal_border
);
float border_mix = smoothstep(
max(internal_border - 0.5, 0.0),
internal_border + 0.5,
internal_distance
);
mixed_color = mix(v_Color, v_BorderColor, border_mix);
} else {
mixed_color = v_Color;
}
float d = distance(
gl_FragCoord.xy,
v_Pos,
v_Scale,
v_BorderRadius
);
float radius_alpha =
1.0 - smoothstep(max(v_BorderRadius - 0.5, 0), v_BorderRadius + 0.5, d);
o_Color = vec4(mixed_color.xyz, mixed_color.w * radius_alpha);
}

BIN
wgpu/src/shader/quad.frag.spv
View File

Binary file not shown.

47
wgpu/src/shader/quad.vert
View File

@ -1,47 +0,0 @@
#version 450
layout(location = 0) in vec2 v_Pos;
layout(location = 1) in vec2 i_Pos;
layout(location = 2) in vec2 i_Scale;
layout(location = 3) in vec4 i_Color;
layout(location = 4) in vec4 i_BorderColor;
layout(location = 5) in float i_BorderRadius;
layout(location = 6) in float i_BorderWidth;
layout (set = 0, binding = 0) uniform Globals {
mat4 u_Transform;
float u_Scale;
};
layout(location = 0) out vec4 o_Color;
layout(location = 1) out vec4 o_BorderColor;
layout(location = 2) out vec2 o_Pos;
layout(location = 3) out vec2 o_Scale;
layout(location = 4) out float o_BorderRadius;
layout(location = 5) out float o_BorderWidth;
void main() {
vec2 p_Pos = i_Pos * u_Scale;
vec2 p_Scale = i_Scale * u_Scale;
float i_BorderRadius = min(
i_BorderRadius,
min(i_Scale.x, i_Scale.y) / 2.0
);
mat4 i_Transform = mat4(
vec4(p_Scale.x + 1.0, 0.0, 0.0, 0.0),
vec4(0.0, p_Scale.y + 1.0, 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
vec4(p_Pos - vec2(0.5, 0.5), 0.0, 1.0)
);
o_Color = i_Color;
o_BorderColor = i_BorderColor;
o_Pos = p_Pos;
o_Scale = p_Scale;
o_BorderRadius = i_BorderRadius * u_Scale;
o_BorderWidth = i_BorderWidth * u_Scale;
gl_Position = u_Transform * i_Transform * vec4(v_Pos, 0.0, 1.0);
}

BIN
wgpu/src/shader/quad.vert.spv
View File

Binary file not shown.

123
wgpu/src/shader/quad.wgsl Normal file
View File

@ -0,0 +1,123 @@
[[block]]
struct Globals {
transform: mat4x4<f32>;
scale: f32;
};
[[group(0), binding(0)]] var<uniform> globals: Globals;
struct VertexInput {
[[location(0)]] v_pos: vec2<f32>;
[[location(1)]] pos: vec2<f32>;
[[location(2)]] scale: vec2<f32>;
[[location(3)]] color: vec4<f32>;
[[location(4)]] border_color: vec4<f32>;
[[location(5)]] border_radius: f32;
[[location(6)]] border_width: f32;
};
struct VertexOutput {
[[builtin(position)]] position: vec4<f32>;
[[location(0)]] color: vec4<f32>;
[[location(1)]] border_color: vec4<f32>;
[[location(2)]] pos: vec2<f32>;
[[location(3)]] scale: vec2<f32>;
[[location(4)]] border_radius: f32;
[[location(5)]] border_width: f32;
};
[[stage(vertex)]]
fn vs_main(input: VertexInput) -> VertexOutput {
var out: VertexOutput;
var pos: vec2<f32> = input.pos * globals.scale;
var scale: vec2<f32> = input.scale * globals.scale;
var border_radius: f32 = min(
input.border_radius,
min(input.scale.x, input.scale.y) / 2.0
);
var transform: mat4x4<f32> = mat4x4<f32>(
vec4<f32>(scale.x + 1.0, 0.0, 0.0, 0.0),
vec4<f32>(0.0, scale.y + 1.0, 0.0, 0.0),
vec4<f32>(0.0, 0.0, 1.0, 0.0),
vec4<f32>(pos - vec2<f32>(0.5, 0.5), 0.0, 1.0)
);
out.color = input.color;
out.border_color = input.border_color;
out.pos = pos;
out.scale = scale;
out.border_radius = border_radius * globals.scale;
out.border_width = input.border_width * globals.scale;
out.position = globals.transform * transform * vec4<f32>(input.v_pos, 0.0, 1.0);
return out;
}
fn distance_alg(
frag_coord: vec2<f32>,
position: vec2<f32>,
size: vec2<f32>,
radius: f32
) -> f32 {
var inner_size: vec2<f32> = size - vec2<f32>(radius, radius) * 2.0;
var top_left: vec2<f32> = position + vec2<f32>(radius, radius);
var bottom_right: vec2<f32> = top_left + inner_size;
var top_left_distance: vec2<f32> = top_left - frag_coord;
var bottom_right_distance: vec2<f32> = frag_coord - bottom_right;
var dist: vec2<f32> = vec2<f32>(
max(max(top_left_distance.x, bottom_right_distance.x), 0.0),
max(max(top_left_distance.y, bottom_right_distance.y), 0.0)
);
return sqrt(dist.x * dist.x + dist.y * dist.y);
}
[[stage(fragment)]]
fn fs_main(
input: VertexOutput,
[[builtin(position)]] coord: vec4<f32>
) -> [[location(0)]] vec4<f32> {
var mixed_color: vec4<f32> = input.color;
if (input.border_width > 0.0) {
var internal_border: f32 = max(
input.border_radius - input.border_width,
0.0
);
var internal_distance: f32 = distance_alg(
vec2<f32>(coord.x, coord.y),
input.pos + vec2<f32>(input.border_width, input.border_width),
input.scale - vec2<f32>(input.border_width * 2.0, input.border_width * 2.0),
internal_border
);
var border_mix: f32 = smoothStep(
max(internal_border - 0.5, 0.0),
internal_border + 0.5,
internal_distance
);
mixed_color = mix(input.color, input.border_color, vec4<f32>(border_mix, border_mix, border_mix, border_mix));
}
var dist: f32 = distance_alg(
vec2<f32>(coord.x, coord.y),
input.pos,
input.scale,
input.border_radius
);
var radius_alpha: f32 = 1.0 - smoothStep(
max(input.border_radius - 0.5, 0.0),
input.border_radius + 0.5,
dist);
return vec4<f32>(radius_alpha, radius_alpha, radius_alpha, radius_alpha);
}

8
wgpu/src/shader/triangle.frag
View File

@ -1,8 +0,0 @@
#version 450
layout(location = 0) in vec4 i_Color;
layout(location = 0) out vec4 o_Color;
void main() {
o_Color = i_Color;
}

BIN
wgpu/src/shader/triangle.frag.spv
View File

Binary file not shown.

15
wgpu/src/shader/triangle.vert
View File

@ -1,15 +0,0 @@
#version 450
layout(location = 0) in vec2 i_Position;
layout(location = 1) in vec4 i_Color;
layout(location = 0) out vec4 o_Color;
layout (set = 0, binding = 0) uniform Globals {
mat4 u_Transform;
};
void main() {
gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0);
o_Color = i_Color;
}

BIN
wgpu/src/shader/triangle.vert.spv
View File

Binary file not shown.

31
wgpu/src/shader/triangle.wgsl Normal file
View File

@ -0,0 +1,31 @@
[[block]]
struct Globals {
transform: mat4x4<f32>;
};
[[group(0), binding(0)]] var<uniform> globals: Globals;
struct VertexInput {
[[location(0)]] position: vec2<f32>;
[[location(1)]] color: vec4<f32>;
};
struct VertexOutput {
[[builtin(position)]] position: vec4<f32>;
[[location(0)]] color: vec4<f32>;
};
[[stage(vertex)]]
fn vs_main(input: VertexInput) -> VertexOutput {
var out: VertexOutput;
out.color = input.color;
out.position = globals.transform * vec4<f32>(input.position, 0.0, 1.0);
return out;
}
[[stage(fragment)]]
fn fs_main(input: VertexOutput) -> [[location(0)]] vec4<f32> {
return input.color;
}

57
wgpu/src/triangle.rs
View File

@ -127,21 +127,19 @@ impl Pipeline {
bind_group_layouts: &[&constants_layout],
});
let vs_module = device.create_shader_module(&wgpu::include_spirv!(
"shader/triangle.vert.spv"
));
let fs_module = device.create_shader_module(&wgpu::include_spirv!(
"shader/triangle.frag.spv"
));
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"))),
flags: wgpu::ShaderFlags::all()
});
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("iced_wgpu::triangle pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &vs_module,
entry_point: "main",
module: &shader,
entry_point: "vs_main",
buffers: &[wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Vertex2D>() as u64,
step_mode: wgpu::InputStepMode::Vertex,
@ -149,40 +147,41 @@ impl Pipeline {
// Position
wgpu::VertexAttribute {
shader_location: 0,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
offset: 0,
},
// Color
wgpu::VertexAttribute {
shader_location: 1,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
offset: 4 * 2,
},
],
}],
},
fragment: Some(wgpu::FragmentState {
module: &fs_module,
entry_point: "main",
module: &shader,
entry_point: "fs_main",
targets: &[wgpu::ColorTargetState {
format,
color_blend: wgpu::BlendState {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha_blend: wgpu::BlendState {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None,
..Default::default()
},
depth_stencil: None,
@ -261,7 +260,8 @@ impl Pipeline {
Uniforms,
>(
)
as u64),
as
u64),
},
}],
});
@ -303,6 +303,8 @@ impl Pipeline {
vertex_buffer.copy_from_slice(vertices);
}
println!("Indices: {} - Index Size: {}", indices_size, self.index_buffer.size);
{
let mut index_buffer = staging_belt.write_buffer(
encoder,
@ -331,6 +333,7 @@ impl Pipeline {
let uniforms = bytemuck::cast_slice(&uniforms);
if let Some(uniforms_size) =
wgpu::BufferSize::new(uniforms.len() as u64)
{
@ -364,8 +367,8 @@ impl Pipeline {
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("iced_wgpu::triangle render pass"),
color_attachments: &[
wgpu::RenderPassColorAttachmentDescriptor {
attachment,
wgpu::RenderPassColorAttachment {
view: attachment,
resolve_target,
ops: wgpu::Operations { load, store: true },
},

49
wgpu/src/triangle/msaa.rs
View File

@ -74,45 +74,44 @@ impl Blit {
bind_group_layouts: &[&constant_layout, &texture_layout],
});
let vs_module = device.create_shader_module(&wgpu::include_spirv!(
"../shader/blit.vert.spv"
));
let fs_module = device.create_shader_module(&wgpu::include_spirv!(
"../shader/blit.frag.spv"
));
let shader = device.create_shader_module(&wgpu::ShaderModuleDescriptor {
label: Some("iced_wgpu::triangle::blit_shader"),
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(include_str!("../shader/blit.wgsl"))),
flags: wgpu::ShaderFlags::all()
});
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("iced_wgpu::triangle::msaa pipeline"),
layout: Some(&layout),
vertex: wgpu::VertexState {
module: &vs_module,
entry_point: "main",
module: &shader,
entry_point: "vs_main",
buffers: &[],
},
fragment: Some(wgpu::FragmentState {
module: &fs_module,
entry_point: "main",
module: &shader,
entry_point: "fs_main",
targets: &[wgpu::ColorTargetState {
format,
color_blend: wgpu::BlendState {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha_blend: wgpu::BlendState {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None,
..Default::default()
},
depth_stencil: None,
@ -178,8 +177,8 @@ impl Blit {
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("iced_wgpu::triangle::msaa render pass"),
color_attachments: &[
wgpu::RenderPassColorAttachmentDescriptor {
attachment: target,
wgpu::RenderPassColorAttachment {
view: target,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Load,
@ -222,7 +221,7 @@ impl Targets {
let extent = wgpu::Extent3d {
width,
height,
depth: 1,
depth_or_array_layers: 1,
};
let attachment = device.create_texture(&wgpu::TextureDescriptor {

4
wgpu/src/window/compositor.rs
View File

@ -133,8 +133,8 @@ impl iced_graphics::window::Compositor for Compositor {
let _ = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("iced_wgpu::window::Compositor render pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.output.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.output.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear({