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

Merge pull request #500 from hecrj/update-wgpu 

Update `wgpu` to `0.6` in `iced_wgpu`
This commit is contained in:
Héctor Ramón 2020-08-31 15:11:34 +02:00 committed by GitHub
parent fb015a85d2 44118263b5
commit ff15ebc547
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 503 additions and 375 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
examples/integration/src/main.rs
View File

@ -7,6 +7,7 @@ use scene::Scene;
use iced_wgpu::{wgpu, Backend, Renderer, Settings, Viewport}; use iced_wgpu::{wgpu, Backend, Renderer, Settings, Viewport};
use iced_winit::{conversion, futures, program, winit, Debug, Size}; use iced_winit::{conversion, futures, program, winit, Debug, Size};
use futures::task::SpawnExt;
use winit::{ use winit::{
dpi::PhysicalPosition, dpi::PhysicalPosition,
event::{Event, ModifiersState, WindowEvent}, event::{Event, ModifiersState, WindowEvent},
@ -29,26 +30,29 @@ pub fn main() {
let mut modifiers = ModifiersState::default(); let mut modifiers = ModifiersState::default();
// Initialize wgpu // Initialize wgpu
let surface = wgpu::Surface::create(&window); let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
let surface = unsafe { instance.create_surface(&window) };
let (mut device, queue) = futures::executor::block_on(async { let (mut device, queue) = futures::executor::block_on(async {
let adapter = wgpu::Adapter::request( let adapter = instance
&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::Default, power_preference: wgpu::PowerPreference::Default,
compatible_surface: Some(&surface), compatible_surface: Some(&surface),
},
wgpu::BackendBit::PRIMARY,
)
.await
.expect("Request adapter");
adapter
.request_device(&wgpu::DeviceDescriptor {
extensions: wgpu::Extensions {
anisotropic_filtering: false,
},
limits: wgpu::Limits::default(),
}) })
.await .await
.expect("Request adapter");
adapter
.request_device(
&wgpu::DeviceDescriptor {
features: wgpu::Features::empty(),
limits: wgpu::Limits::default(),
shader_validation: false,
},
None,
)
.await
.expect("Request device")
}); });
let format = wgpu::TextureFormat::Bgra8UnormSrgb; let format = wgpu::TextureFormat::Bgra8UnormSrgb;
@ -69,6 +73,10 @@ pub fn main() {
}; };
let mut resized = false; let mut resized = false;
// Initialize staging belt and local pool
let mut staging_belt = wgpu::util::StagingBelt::new(5 * 1024);
let mut local_pool = futures::executor::LocalPool::new();
// Initialize scene and GUI controls // Initialize scene and GUI controls
let scene = Scene::new(&mut device); let scene = Scene::new(&mut device);
let controls = Controls::new(); let controls = Controls::new();
@ -160,7 +168,7 @@ pub fn main() {
resized = false; resized = false;
} }
let frame = swap_chain.get_next_texture().expect("Next frame"); let frame = swap_chain.get_current_frame().expect("Next frame");
let mut encoder = device.create_command_encoder( let mut encoder = device.create_command_encoder(
&wgpu::CommandEncoderDescriptor { label: None }, &wgpu::CommandEncoderDescriptor { label: None },
@ -171,7 +179,7 @@ pub fn main() {
{ {
// We clear the frame // We clear the frame
let mut render_pass = scene.clear( let mut render_pass = scene.clear(
&frame.view, &frame.output.view,
&mut encoder, &mut encoder,
program.background_color(), program.background_color(),
); );
@ -183,22 +191,32 @@ pub fn main() {
// And then iced on top // And then iced on top
let mouse_interaction = renderer.backend_mut().draw( let mouse_interaction = renderer.backend_mut().draw(
&mut device, &mut device,
&mut staging_belt,
&mut encoder, &mut encoder,
&frame.view, &frame.output.view,
&viewport, &viewport,
state.primitive(), state.primitive(),
&debug.overlay(), &debug.overlay(),
); );
// Then we submit the work // Then we submit the work
queue.submit(&[encoder.finish()]); staging_belt.finish();
queue.submit(Some(encoder.finish()));
// And update the mouse cursor // Update the mouse cursor
window.set_cursor_icon( window.set_cursor_icon(
iced_winit::conversion::mouse_interaction( iced_winit::conversion::mouse_interaction(
mouse_interaction, mouse_interaction,
), ),
); );
// And recall staging buffers
local_pool
.spawner()
.spawn(staging_belt.recall())
.expect("Recall staging buffers");
local_pool.run_until_stalled();
} }
_ => {} _ => {}
} }

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

@ -22,17 +22,18 @@ impl Scene {
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor { color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: target, attachment: target,
resolve_target: None, resolve_target: None,
load_op: wgpu::LoadOp::Clear, ops: wgpu::Operations {
store_op: wgpu::StoreOp::Store, load: wgpu::LoadOp::Clear({
clear_color: { let [r, g, b, a] = background_color.into_linear();
let [r, g, b, a] = background_color.into_linear();
wgpu::Color { wgpu::Color {
r: r as f64, r: r as f64,
g: g as f64, g: g as f64,
b: b as f64, b: b as f64,
a: a as f64, a: a as f64,
} }
}),
store: true,
}, },
}], }],
depth_stencil_attachment: None, depth_stencil_attachment: None,
@ -46,25 +47,23 @@ impl Scene {
} }
fn build_pipeline(device: &wgpu::Device) -> wgpu::RenderPipeline { fn build_pipeline(device: &wgpu::Device) -> wgpu::RenderPipeline {
let vs = include_bytes!("shader/vert.spv"); let vs_module =
let fs = include_bytes!("shader/frag.spv"); device.create_shader_module(wgpu::include_spirv!("shader/vert.spv"));
let vs_module = device.create_shader_module( let fs_module =
&wgpu::read_spirv(std::io::Cursor::new(&vs[..])).unwrap(), device.create_shader_module(wgpu::include_spirv!("shader/frag.spv"));
);
let fs_module = device.create_shader_module(
&wgpu::read_spirv(std::io::Cursor::new(&fs[..])).unwrap(),
);
let pipeline_layout = let pipeline_layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
push_constant_ranges: &[],
bind_group_layouts: &[], bind_group_layouts: &[],
}); });
let pipeline = let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
layout: &pipeline_layout, label: None,
layout: Some(&pipeline_layout),
vertex_stage: wgpu::ProgrammableStageDescriptor { vertex_stage: wgpu::ProgrammableStageDescriptor {
module: &vs_module, module: &vs_module,
entry_point: "main", entry_point: "main",
@ -76,9 +75,7 @@ fn build_pipeline(device: &wgpu::Device) -> wgpu::RenderPipeline {
rasterization_state: Some(wgpu::RasterizationStateDescriptor { rasterization_state: Some(wgpu::RasterizationStateDescriptor {
front_face: wgpu::FrontFace::Ccw, front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::None, cull_mode: wgpu::CullMode::None,
depth_bias: 0, ..Default::default()
depth_bias_slope_scale: 0.0,
depth_bias_clamp: 0.0,
}), }),
primitive_topology: wgpu::PrimitiveTopology::TriangleList, primitive_topology: wgpu::PrimitiveTopology::TriangleList,
color_states: &[wgpu::ColorStateDescriptor { color_states: &[wgpu::ColorStateDescriptor {

8
wgpu/Cargo.toml
View File

@ -13,17 +13,15 @@ canvas = ["iced_graphics/canvas"]
default_system_font = ["iced_graphics/font-source"] default_system_font = ["iced_graphics/font-source"]
[dependencies] [dependencies]
wgpu = "0.5" wgpu = "0.6"
wgpu_glyph = "0.9" wgpu_glyph = "0.10"
glyph_brush = "0.7" glyph_brush = "0.7"
zerocopy = "0.3" zerocopy = "0.3"
bytemuck = "1.2" bytemuck = "1.2"
raw-window-handle = "0.3" raw-window-handle = "0.3"
log = "0.4" log = "0.4"
guillotiere = "0.5" guillotiere = "0.5"
# Pin `gfx-memory` until https://github.com/gfx-rs/wgpu-rs/issues/261 is futures = "0.3"
# resolved
gfx-memory = "=0.1.1"
[dependencies.iced_native] [dependencies.iced_native]
version = "0.2" version = "0.2"

7
wgpu/src/backend.rs
View File

@ -64,6 +64,7 @@ impl Backend {
pub fn draw<T: AsRef<str>>( pub fn draw<T: AsRef<str>>(
&mut self, &mut self,
device: &wgpu::Device, device: &wgpu::Device,
staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder, encoder: &mut wgpu::CommandEncoder,
frame: &wgpu::TextureView, frame: &wgpu::TextureView,
viewport: &Viewport, viewport: &Viewport,
@ -85,6 +86,7 @@ impl Backend {
scale_factor, scale_factor,
transformation, transformation,
&layer, &layer,
staging_belt,
encoder, encoder,
&frame, &frame,
target_size.width, target_size.width,
@ -104,6 +106,7 @@ impl Backend {
scale_factor: f32, scale_factor: f32,
transformation: Transformation, transformation: Transformation,
layer: &Layer<'_>, layer: &Layer<'_>,
staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder, encoder: &mut wgpu::CommandEncoder,
target: &wgpu::TextureView, target: &wgpu::TextureView,
target_width: u32, target_width: u32,
@ -114,6 +117,7 @@ impl Backend {
if !layer.quads.is_empty() { if !layer.quads.is_empty() {
self.quad_pipeline.draw( self.quad_pipeline.draw(
device, device,
staging_belt,
encoder, encoder,
&layer.quads, &layer.quads,
transformation, transformation,
@ -129,6 +133,7 @@ impl Backend {
self.triangle_pipeline.draw( self.triangle_pipeline.draw(
device, device,
staging_belt,
encoder, encoder,
target, target,
target_width, target_width,
@ -147,6 +152,7 @@ impl Backend {
self.image_pipeline.draw( self.image_pipeline.draw(
device, device,
staging_belt,
encoder, encoder,
&layer.images, &layer.images,
scaled, scaled,
@ -225,6 +231,7 @@ impl Backend {
self.text_pipeline.draw_queued( self.text_pipeline.draw_queued(
device, device,
staging_belt,
encoder, encoder,
target, target,
transformation, transformation,

175
wgpu/src/image.rs
View File

@ -42,6 +42,8 @@ pub struct Pipeline {
impl Pipeline { impl Pipeline {
pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self { pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
use wgpu::util::DeviceExt;
let sampler = device.create_sampler(&wgpu::SamplerDescriptor { let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
address_mode_u: wgpu::AddressMode::ClampToEdge, address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge, address_mode_v: wgpu::AddressMode::ClampToEdge,
@ -49,50 +51,52 @@ impl Pipeline {
mag_filter: wgpu::FilterMode::Linear, mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear, min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear, mipmap_filter: wgpu::FilterMode::Linear,
lod_min_clamp: -100.0, ..Default::default()
lod_max_clamp: 100.0,
compare: wgpu::CompareFunction::Always,
}); });
let constant_layout = let constant_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None, label: Some("iced_wgpu::image constants layout"),
bindings: &[ entries: &[
wgpu::BindGroupLayoutEntry { wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::VERTEX, visibility: wgpu::ShaderStage::VERTEX,
ty: wgpu::BindingType::UniformBuffer { dynamic: false }, ty: wgpu::BindingType::UniformBuffer {
dynamic: false,
min_binding_size: wgpu::BufferSize::new(
mem::size_of::<Uniforms>() as u64,
),
},
count: None,
}, },
wgpu::BindGroupLayoutEntry { wgpu::BindGroupLayoutEntry {
binding: 1, binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT, visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Sampler { comparison: false }, ty: wgpu::BindingType::Sampler { comparison: false },
count: None,
}, },
], ],
}); });
let uniforms = Uniforms { let uniforms_buffer = device.create_buffer(&wgpu::BufferDescriptor {
transform: Transformation::identity().into(), label: Some("iced_wgpu::image uniforms buffer"),
}; size: mem::size_of::<Uniforms>() as u64,
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
let uniforms_buffer = device.create_buffer_with_data( mapped_at_creation: false,
uniforms.as_bytes(), });
wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
);
let constant_bind_group = let constant_bind_group =
device.create_bind_group(&wgpu::BindGroupDescriptor { device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None, label: Some("iced_wgpu::image constants bind group"),
layout: &constant_layout, layout: &constant_layout,
bindings: &[ entries: &[
wgpu::Binding { wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::Buffer { resource: wgpu::BindingResource::Buffer(
buffer: &uniforms_buffer, uniforms_buffer.slice(..),
range: 0..std::mem::size_of::<Uniforms>() as u64, ),
},
}, },
wgpu::Binding { wgpu::BindGroupEntry {
binding: 1, binding: 1,
resource: wgpu::BindingResource::Sampler(&sampler), resource: wgpu::BindingResource::Sampler(&sampler),
}, },
@ -101,8 +105,8 @@ impl Pipeline {
let texture_layout = let texture_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None, label: Some("iced_wgpu::image texture atlas layout"),
bindings: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT, visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::SampledTexture { ty: wgpu::BindingType::SampledTexture {
@ -110,29 +114,29 @@ impl Pipeline {
component_type: wgpu::TextureComponentType::Float, component_type: wgpu::TextureComponentType::Float,
multisampled: false, multisampled: false,
}, },
count: None,
}], }],
}); });
let layout = let layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("iced_wgpu::image pipeline layout"),
push_constant_ranges: &[],
bind_group_layouts: &[&constant_layout, &texture_layout], bind_group_layouts: &[&constant_layout, &texture_layout],
}); });
let vs = include_bytes!("shader/image.vert.spv"); let vs_module = device.create_shader_module(wgpu::include_spirv!(
let vs_module = device.create_shader_module( "shader/image.vert.spv"
&wgpu::read_spirv(std::io::Cursor::new(&vs[..])) ));
.expect("Read image vertex shader as SPIR-V"),
);
let fs = include_bytes!("shader/image.frag.spv"); let fs_module = device.create_shader_module(wgpu::include_spirv!(
let fs_module = device.create_shader_module( "shader/image.frag.spv"
&wgpu::read_spirv(std::io::Cursor::new(&fs[..])) ));
.expect("Read image fragment shader as SPIR-V"),
);
let pipeline = let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
layout: &layout, label: Some("iced_wgpu::image pipeline"),
layout: Some(&layout),
vertex_stage: wgpu::ProgrammableStageDescriptor { vertex_stage: wgpu::ProgrammableStageDescriptor {
module: &vs_module, module: &vs_module,
entry_point: "main", entry_point: "main",
@ -144,9 +148,7 @@ impl Pipeline {
rasterization_state: Some(wgpu::RasterizationStateDescriptor { rasterization_state: Some(wgpu::RasterizationStateDescriptor {
front_face: wgpu::FrontFace::Cw, front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None, cull_mode: wgpu::CullMode::None,
depth_bias: 0, ..Default::default()
depth_bias_slope_scale: 0.0,
depth_bias_clamp: 0.0,
}), }),
primitive_topology: wgpu::PrimitiveTopology::TriangleList, primitive_topology: wgpu::PrimitiveTopology::TriangleList,
color_states: &[wgpu::ColorStateDescriptor { color_states: &[wgpu::ColorStateDescriptor {
@ -214,28 +216,33 @@ impl Pipeline {
alpha_to_coverage_enabled: false, alpha_to_coverage_enabled: false,
}); });
let vertices = device.create_buffer_with_data( let vertices =
QUAD_VERTS.as_bytes(), device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
wgpu::BufferUsage::VERTEX, label: Some("iced_wgpu::image vertex buffer"),
); contents: QUAD_VERTS.as_bytes(),
usage: wgpu::BufferUsage::VERTEX,
});
let indices = device.create_buffer_with_data( let indices =
QUAD_INDICES.as_bytes(), device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
wgpu::BufferUsage::INDEX, label: Some("iced_wgpu::image index buffer"),
); contents: QUAD_INDICES.as_bytes(),
usage: wgpu::BufferUsage::INDEX,
});
let instances = device.create_buffer(&wgpu::BufferDescriptor { let instances = device.create_buffer(&wgpu::BufferDescriptor {
label: None, label: Some("iced_wgpu::image instance buffer"),
size: mem::size_of::<Instance>() as u64 * Instance::MAX as u64, size: mem::size_of::<Instance>() as u64 * Instance::MAX as u64,
usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST, usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
mapped_at_creation: false,
}); });
let texture_atlas = Atlas::new(device); let texture_atlas = Atlas::new(device);
let texture = device.create_bind_group(&wgpu::BindGroupDescriptor { let texture = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None, label: Some("iced_wgpu::image texture atlas bind group"),
layout: &texture_layout, layout: &texture_layout,
bindings: &[wgpu::Binding { entries: &[wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::TextureView( resource: wgpu::BindingResource::TextureView(
&texture_atlas.view(), &texture_atlas.view(),
@ -282,6 +289,7 @@ impl Pipeline {
pub fn draw( pub fn draw(
&mut self, &mut self,
device: &wgpu::Device, device: &wgpu::Device,
staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder, encoder: &mut wgpu::CommandEncoder,
images: &[layer::Image], images: &[layer::Image],
transformation: Transformation, transformation: Transformation,
@ -354,9 +362,9 @@ impl Pipeline {
self.texture = self.texture =
device.create_bind_group(&wgpu::BindGroupDescriptor { device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None, label: Some("iced_wgpu::image texture atlas bind group"),
layout: &self.texture_layout, layout: &self.texture_layout,
bindings: &[wgpu::Binding { entries: &[wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::TextureView( resource: wgpu::BindingResource::TextureView(
&self.texture_atlas.view(), &self.texture_atlas.view(),
@ -367,26 +375,23 @@ impl Pipeline {
self.texture_version = texture_version; self.texture_version = texture_version;
} }
let uniforms_buffer = device.create_buffer_with_data( {
Uniforms { let mut uniforms_buffer = staging_belt.write_buffer(
transform: transformation.into(), encoder,
} &self.uniforms,
.as_bytes(), 0,
wgpu::BufferUsage::COPY_SRC, wgpu::BufferSize::new(mem::size_of::<Uniforms>() as u64)
); .unwrap(),
device,
);
encoder.copy_buffer_to_buffer( uniforms_buffer.copy_from_slice(
&uniforms_buffer, Uniforms {
0, transform: transformation.into(),
&self.uniforms, }
0, .as_bytes(),
std::mem::size_of::<Uniforms>() as u64, );
); }
let instances_buffer = device.create_buffer_with_data(
instances.as_bytes(),
wgpu::BufferUsage::COPY_SRC,
);
let mut i = 0; let mut i = 0;
let total = instances.len(); let total = instances.len();
@ -395,27 +400,29 @@ impl Pipeline {
let end = (i + Instance::MAX).min(total); let end = (i + Instance::MAX).min(total);
let amount = end - i; let amount = end - i;
encoder.copy_buffer_to_buffer( let mut instances_buffer = staging_belt.write_buffer(
&instances_buffer, encoder,
(i * std::mem::size_of::<Instance>()) as u64,
&self.instances, &self.instances,
0, 0,
(amount * std::mem::size_of::<Instance>()) as u64, wgpu::BufferSize::new(
(amount * std::mem::size_of::<Instance>()) as u64,
)
.unwrap(),
device,
); );
instances_buffer
.copy_from_slice(instances[i..i + amount].as_bytes());
let mut render_pass = let mut render_pass =
encoder.begin_render_pass(&wgpu::RenderPassDescriptor { encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[ color_attachments: &[
wgpu::RenderPassColorAttachmentDescriptor { wgpu::RenderPassColorAttachmentDescriptor {
attachment: target, attachment: target,
resolve_target: None, resolve_target: None,
load_op: wgpu::LoadOp::Load, ops: wgpu::Operations {
store_op: wgpu::StoreOp::Store, load: wgpu::LoadOp::Load,
clear_color: wgpu::Color { store: true,
r: 0.0,
g: 0.0,
b: 0.0,
a: 0.0,
}, },
}, },
], ],
@ -425,9 +432,9 @@ impl Pipeline {
render_pass.set_pipeline(&self.pipeline); render_pass.set_pipeline(&self.pipeline);
render_pass.set_bind_group(0, &self.constants, &[]); render_pass.set_bind_group(0, &self.constants, &[]);
render_pass.set_bind_group(1, &self.texture, &[]); render_pass.set_bind_group(1, &self.texture, &[]);
render_pass.set_index_buffer(&self.indices, 0, 0); render_pass.set_index_buffer(self.indices.slice(..));
render_pass.set_vertex_buffer(0, &self.vertices, 0, 0); render_pass.set_vertex_buffer(0, self.vertices.slice(..));
render_pass.set_vertex_buffer(1, &self.instances, 0, 0); render_pass.set_vertex_buffer(1, self.instances.slice(..));
render_pass.set_scissor_rect( render_pass.set_scissor_rect(
bounds.x, bounds.x,

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

@ -28,9 +28,8 @@ impl Atlas {
}; };
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label: None, label: Some("iced_wgpu::image texture atlas"),
size: extent, size: extent,
array_layer_count: 2,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
@ -40,12 +39,15 @@ impl Atlas {
| wgpu::TextureUsage::SAMPLED, | wgpu::TextureUsage::SAMPLED,
}); });
let texture_view = texture.create_default_view(); let texture_view = texture.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2Array),
..Default::default()
});
Atlas { Atlas {
texture, texture,
texture_view, texture_view,
layers: vec![Layer::Empty, Layer::Empty], layers: vec![Layer::Empty],
} }
} }
@ -65,6 +67,8 @@ impl Atlas {
device: &wgpu::Device, device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder, encoder: &mut wgpu::CommandEncoder,
) -> Option<Entry> { ) -> Option<Entry> {
use wgpu::util::DeviceExt;
let entry = { let entry = {
let current_size = self.layers.len(); let current_size = self.layers.len();
let entry = self.allocate(width, height)?; let entry = self.allocate(width, height)?;
@ -78,8 +82,31 @@ impl Atlas {
log::info!("Allocated atlas entry: {:?}", entry); log::info!("Allocated atlas entry: {:?}", entry);
// It is a webgpu requirement that:
// BufferCopyView.layout.bytes_per_row % wgpu::COPY_BYTES_PER_ROW_ALIGNMENT == 0
// So we calculate padded_width by rounding width up to the next
// multiple of wgpu::COPY_BYTES_PER_ROW_ALIGNMENT.
let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
let padding = (align - (4 * width) % align) % align;
let padded_width = (4 * width + padding) as usize;
let padded_data_size = padded_width * height as usize;
let mut padded_data = vec![0; padded_data_size];
for row in 0..height as usize {
let offset = row * padded_width;
padded_data[offset..offset + 4 * width as usize].copy_from_slice(
&data[row * 4 * width as usize..(row + 1) * 4 * width as usize],
)
}
let buffer = let buffer =
device.create_buffer_with_data(data, wgpu::BufferUsage::COPY_SRC); device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("iced_wgpu::image staging buffer"),
contents: &padded_data,
usage: wgpu::BufferUsage::COPY_SRC,
});
match &entry { match &entry {
Entry::Contiguous(allocation) => { Entry::Contiguous(allocation) => {
@ -87,6 +114,7 @@ impl Atlas {
&buffer, &buffer,
width, width,
height, height,
padding,
0, 0,
&allocation, &allocation,
encoder, encoder,
@ -95,12 +123,13 @@ impl Atlas {
Entry::Fragmented { fragments, .. } => { Entry::Fragmented { fragments, .. } => {
for fragment in fragments { for fragment in fragments {
let (x, y) = fragment.position; let (x, y) = fragment.position;
let offset = (y * width + x) as usize * 4; let offset = (y * padded_width as u32 + 4 * x) as usize;
self.upload_allocation( self.upload_allocation(
&buffer, &buffer,
width, width,
height, height,
padding,
offset, offset,
&fragment.allocation, &fragment.allocation,
encoder, encoder,
@ -253,6 +282,7 @@ impl Atlas {
buffer: &wgpu::Buffer, buffer: &wgpu::Buffer,
image_width: u32, image_width: u32,
image_height: u32, image_height: u32,
padding: u32,
offset: usize, offset: usize,
allocation: &Allocation, allocation: &Allocation,
encoder: &mut wgpu::CommandEncoder, encoder: &mut wgpu::CommandEncoder,
@ -270,15 +300,20 @@ impl Atlas {
encoder.copy_buffer_to_texture( encoder.copy_buffer_to_texture(
wgpu::BufferCopyView { wgpu::BufferCopyView {
buffer, buffer,
offset: offset as u64, layout: wgpu::TextureDataLayout {
bytes_per_row: 4 * image_width, offset: offset as u64,
rows_per_image: image_height, bytes_per_row: 4 * image_width + padding,
rows_per_image: image_height,
},
}, },
wgpu::TextureCopyView { wgpu::TextureCopyView {
texture: &self.texture, texture: &self.texture,
array_layer: layer as u32,
mip_level: 0, mip_level: 0,
origin: wgpu::Origin3d { x, y, z: 0 }, origin: wgpu::Origin3d {
x,
y,
z: layer as u32,
},
}, },
extent, extent,
); );
@ -295,13 +330,12 @@ impl Atlas {
} }
let new_texture = device.create_texture(&wgpu::TextureDescriptor { let new_texture = device.create_texture(&wgpu::TextureDescriptor {
label: None, label: Some("iced_wgpu::image texture atlas"),
size: wgpu::Extent3d { size: wgpu::Extent3d {
width: SIZE, width: SIZE,
height: SIZE, height: SIZE,
depth: 1, depth: self.layers.len() as u32,
}, },
array_layer_count: self.layers.len() as u32,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
@ -323,15 +357,21 @@ impl Atlas {
encoder.copy_texture_to_texture( encoder.copy_texture_to_texture(
wgpu::TextureCopyView { wgpu::TextureCopyView {
texture: &self.texture, texture: &self.texture,
array_layer: i as u32,
mip_level: 0, mip_level: 0,
origin: wgpu::Origin3d { x: 0, y: 0, z: 0 }, origin: wgpu::Origin3d {
x: 0,
y: 0,
z: i as u32,
},
}, },
wgpu::TextureCopyView { wgpu::TextureCopyView {
texture: &new_texture, texture: &new_texture,
array_layer: i as u32,
mip_level: 0, mip_level: 0,
origin: wgpu::Origin3d { x: 0, y: 0, z: 0 }, origin: wgpu::Origin3d {
x: 0,
y: 0,
z: i as u32,
},
}, },
wgpu::Extent3d { wgpu::Extent3d {
width: SIZE, width: SIZE,
@ -342,6 +382,10 @@ impl Atlas {
} }
self.texture = new_texture; self.texture = new_texture;
self.texture_view = self.texture.create_default_view(); self.texture_view =
self.texture.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2Array),
..Default::default()
});
} }
} }

2
wgpu/src/lib.rs
View File

@ -23,7 +23,7 @@
#![deny(missing_docs)] #![deny(missing_docs)]
#![deny(missing_debug_implementations)] #![deny(missing_debug_implementations)]
#![deny(unused_results)] #![deny(unused_results)]
#![forbid(unsafe_code)] #![deny(unsafe_code)]
#![forbid(rust_2018_idioms)] #![forbid(rust_2018_idioms)]
#![cfg_attr(docsrs, feature(doc_cfg))] #![cfg_attr(docsrs, feature(doc_cfg))]

134
wgpu/src/quad.rs
View File

@ -3,6 +3,7 @@ use iced_graphics::layer;
use iced_native::Rectangle; use iced_native::Rectangle;
use std::mem; use std::mem;
use wgpu::util::DeviceExt;
use zerocopy::AsBytes; use zerocopy::AsBytes;
#[derive(Debug)] #[derive(Debug)]
@ -19,51 +20,55 @@ impl Pipeline {
pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Pipeline { pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Pipeline {
let constant_layout = let constant_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None, label: Some("iced_wgpu::quad uniforms layout"),
bindings: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::VERTEX, visibility: wgpu::ShaderStage::VERTEX,
ty: wgpu::BindingType::UniformBuffer { dynamic: false }, ty: wgpu::BindingType::UniformBuffer {
dynamic: false,
min_binding_size: wgpu::BufferSize::new(
mem::size_of::<Uniforms>() as u64,
),
},
count: None,
}], }],
}); });
let constants_buffer = device.create_buffer_with_data( let constants_buffer = device.create_buffer(&wgpu::BufferDescriptor {
Uniforms::default().as_bytes(), label: Some("iced_wgpu::quad uniforms buffer"),
wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST, size: mem::size_of::<Uniforms>() as u64,
); usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
mapped_at_creation: false,
});
let constants = device.create_bind_group(&wgpu::BindGroupDescriptor { let constants = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None, label: Some("iced_wgpu::quad uniforms bind group"),
layout: &constant_layout, layout: &constant_layout,
bindings: &[wgpu::Binding { entries: &[wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::Buffer { resource: wgpu::BindingResource::Buffer(
buffer: &constants_buffer, constants_buffer.slice(..),
range: 0..std::mem::size_of::<Uniforms>() as u64, ),
},
}], }],
}); });
let layout = let layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("iced_wgpu::quad pipeline layout"),
push_constant_ranges: &[],
bind_group_layouts: &[&constant_layout], bind_group_layouts: &[&constant_layout],
}); });
let vs = include_bytes!("shader/quad.vert.spv"); let vs_module = device
let vs_module = device.create_shader_module( .create_shader_module(wgpu::include_spirv!("shader/quad.vert.spv"));
&wgpu::read_spirv(std::io::Cursor::new(&vs[..]))
.expect("Read quad vertex shader as SPIR-V"),
);
let fs = include_bytes!("shader/quad.frag.spv"); let fs_module = device
let fs_module = device.create_shader_module( .create_shader_module(wgpu::include_spirv!("shader/quad.frag.spv"));
&wgpu::read_spirv(std::io::Cursor::new(&fs[..]))
.expect("Read quad fragment shader as SPIR-V"),
);
let pipeline = let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
layout: &layout, label: Some("iced_wgpu::quad pipeline"),
layout: Some(&layout),
vertex_stage: wgpu::ProgrammableStageDescriptor { vertex_stage: wgpu::ProgrammableStageDescriptor {
module: &vs_module, module: &vs_module,
entry_point: "main", entry_point: "main",
@ -75,9 +80,7 @@ impl Pipeline {
rasterization_state: Some(wgpu::RasterizationStateDescriptor { rasterization_state: Some(wgpu::RasterizationStateDescriptor {
front_face: wgpu::FrontFace::Cw, front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None, cull_mode: wgpu::CullMode::None,
depth_bias: 0, ..Default::default()
depth_bias_slope_scale: 0.0,
depth_bias_clamp: 0.0,
}), }),
primitive_topology: wgpu::PrimitiveTopology::TriangleList, primitive_topology: wgpu::PrimitiveTopology::TriangleList,
color_states: &[wgpu::ColorStateDescriptor { color_states: &[wgpu::ColorStateDescriptor {
@ -150,20 +153,25 @@ impl Pipeline {
alpha_to_coverage_enabled: false, alpha_to_coverage_enabled: false,
}); });
let vertices = device.create_buffer_with_data( let vertices =
QUAD_VERTS.as_bytes(), device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
wgpu::BufferUsage::VERTEX, label: Some("iced_wgpu::quad vertex buffer"),
); contents: QUAD_VERTS.as_bytes(),
usage: wgpu::BufferUsage::VERTEX,
});
let indices = device.create_buffer_with_data( let indices =
QUAD_INDICES.as_bytes(), device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
wgpu::BufferUsage::INDEX, label: Some("iced_wgpu::quad index buffer"),
); contents: QUAD_INDICES.as_bytes(),
usage: wgpu::BufferUsage::INDEX,
});
let instances = device.create_buffer(&wgpu::BufferDescriptor { let instances = device.create_buffer(&wgpu::BufferDescriptor {
label: None, label: Some("iced_wgpu::quad instance buffer"),
size: mem::size_of::<layer::Quad>() as u64 * MAX_INSTANCES as u64, size: mem::size_of::<layer::Quad>() as u64 * MAX_INSTANCES as u64,
usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST, usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
mapped_at_creation: false,
}); });
Pipeline { Pipeline {
@ -179,6 +187,7 @@ impl Pipeline {
pub fn draw( pub fn draw(
&mut self, &mut self,
device: &wgpu::Device, device: &wgpu::Device,
staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder, encoder: &mut wgpu::CommandEncoder,
instances: &[layer::Quad], instances: &[layer::Quad],
transformation: Transformation, transformation: Transformation,
@ -188,18 +197,18 @@ impl Pipeline {
) { ) {
let uniforms = Uniforms::new(transformation, scale); let uniforms = Uniforms::new(transformation, scale);
let constants_buffer = device.create_buffer_with_data( {
uniforms.as_bytes(), let mut constants_buffer = staging_belt.write_buffer(
wgpu::BufferUsage::COPY_SRC, encoder,
); &self.constants_buffer,
0,
wgpu::BufferSize::new(mem::size_of::<Uniforms>() as u64)
.unwrap(),
device,
);
encoder.copy_buffer_to_buffer( constants_buffer.copy_from_slice(uniforms.as_bytes());
&constants_buffer, }
0,
&self.constants_buffer,
0,
std::mem::size_of::<Uniforms>() as u64,
);
let mut i = 0; let mut i = 0;
let total = instances.len(); let total = instances.len();
@ -208,19 +217,18 @@ impl Pipeline {
let end = (i + MAX_INSTANCES).min(total); let end = (i + MAX_INSTANCES).min(total);
let amount = end - i; let amount = end - i;
let instance_buffer = device.create_buffer_with_data( let instance_bytes = bytemuck::cast_slice(&instances[i..end]);
bytemuck::cast_slice(&instances[i..end]),
wgpu::BufferUsage::COPY_SRC,
);
encoder.copy_buffer_to_buffer( let mut instance_buffer = staging_belt.write_buffer(
&instance_buffer, encoder,
0,
&self.instances, &self.instances,
0, 0,
(mem::size_of::<layer::Quad>() * amount) as u64, wgpu::BufferSize::new(instance_bytes.len() as u64).unwrap(),
device,
); );
instance_buffer.copy_from_slice(instance_bytes);
{ {
let mut render_pass = let mut render_pass =
encoder.begin_render_pass(&wgpu::RenderPassDescriptor { encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@ -228,13 +236,9 @@ impl Pipeline {
wgpu::RenderPassColorAttachmentDescriptor { wgpu::RenderPassColorAttachmentDescriptor {
attachment: target, attachment: target,
resolve_target: None, resolve_target: None,
load_op: wgpu::LoadOp::Load, ops: wgpu::Operations {
store_op: wgpu::StoreOp::Store, load: wgpu::LoadOp::Load,
clear_color: wgpu::Color { store: true,
r: 0.0,
g: 0.0,
b: 0.0,
a: 0.0,
}, },
}, },
], ],
@ -243,9 +247,9 @@ impl Pipeline {
render_pass.set_pipeline(&self.pipeline); render_pass.set_pipeline(&self.pipeline);
render_pass.set_bind_group(0, &self.constants, &[]); render_pass.set_bind_group(0, &self.constants, &[]);
render_pass.set_index_buffer(&self.indices, 0, 0); render_pass.set_index_buffer(self.indices.slice(..));
render_pass.set_vertex_buffer(0, &self.vertices, 0, 0); render_pass.set_vertex_buffer(0, self.vertices.slice(..));
render_pass.set_vertex_buffer(1, &self.instances, 0, 0); render_pass.set_vertex_buffer(1, self.instances.slice(..));
render_pass.set_scissor_rect( render_pass.set_scissor_rect(
bounds.x, bounds.x,
bounds.y, bounds.y,

2
wgpu/src/text.rs
View File

@ -65,6 +65,7 @@ impl Pipeline {
pub fn draw_queued( pub fn draw_queued(
&mut self, &mut self,
device: &wgpu::Device, device: &wgpu::Device,
staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder, encoder: &mut wgpu::CommandEncoder,
target: &wgpu::TextureView, target: &wgpu::TextureView,
transformation: Transformation, transformation: Transformation,
@ -74,6 +75,7 @@ impl Pipeline {
.borrow_mut() .borrow_mut()
.draw_queued_with_transform_and_scissoring( .draw_queued_with_transform_and_scissoring(
device, device,
staging_belt,
encoder, encoder,
target, target,
transformation.into(), transformation.into(),

204
wgpu/src/triangle.rs
View File

@ -8,7 +8,7 @@ pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
mod msaa; mod msaa;
const UNIFORM_BUFFER_SIZE: usize = 100; const UNIFORM_BUFFER_SIZE: usize = 50;
const VERTEX_BUFFER_SIZE: usize = 10_000; const VERTEX_BUFFER_SIZE: usize = 10_000;
const INDEX_BUFFER_SIZE: usize = 10_000; const INDEX_BUFFER_SIZE: usize = 10_000;
@ -25,6 +25,7 @@ pub(crate) struct Pipeline {
#[derive(Debug)] #[derive(Debug)]
struct Buffer<T> { struct Buffer<T> {
label: &'static str,
raw: wgpu::Buffer, raw: wgpu::Buffer,
size: usize, size: usize,
usage: wgpu::BufferUsage, usage: wgpu::BufferUsage,
@ -33,17 +34,20 @@ struct Buffer<T> {
impl<T> Buffer<T> { impl<T> Buffer<T> {
pub fn new( pub fn new(
label: &'static str,
device: &wgpu::Device, device: &wgpu::Device,
size: usize, size: usize,
usage: wgpu::BufferUsage, usage: wgpu::BufferUsage,
) -> Self { ) -> Self {
let raw = device.create_buffer(&wgpu::BufferDescriptor { let raw = device.create_buffer(&wgpu::BufferDescriptor {
label: None, label: Some(label),
size: (std::mem::size_of::<T>() * size) as u64, size: (std::mem::size_of::<T>() * size) as u64,
usage, usage,
mapped_at_creation: false,
}); });
Buffer { Buffer {
label,
raw, raw,
size, size,
usage, usage,
@ -56,9 +60,10 @@ impl<T> Buffer<T> {
if needs_resize { if needs_resize {
self.raw = device.create_buffer(&wgpu::BufferDescriptor { self.raw = device.create_buffer(&wgpu::BufferDescriptor {
label: None, label: Some(self.label),
size: (std::mem::size_of::<T>() * size) as u64, size: (std::mem::size_of::<T>() * size) as u64,
usage: self.usage, usage: self.usage,
mapped_at_creation: false,
}); });
self.size = size; self.size = size;
@ -76,15 +81,22 @@ impl Pipeline {
) -> Pipeline { ) -> Pipeline {
let constants_layout = let constants_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None, label: Some("iced_wgpu::triangle uniforms layout"),
bindings: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::VERTEX, 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( let constants_buffer = Buffer::new(
"iced_wgpu::triangle uniforms buffer",
device, device,
UNIFORM_BUFFER_SIZE, UNIFORM_BUFFER_SIZE,
wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST, wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
@ -92,37 +104,37 @@ impl Pipeline {
let constant_bind_group = let constant_bind_group =
device.create_bind_group(&wgpu::BindGroupDescriptor { device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None, label: Some("iced_wgpu::triangle uniforms bind group"),
layout: &constants_layout, layout: &constants_layout,
bindings: &[wgpu::Binding { entries: &[wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::Buffer { resource: wgpu::BindingResource::Buffer(
buffer: &constants_buffer.raw, constants_buffer
range: 0..std::mem::size_of::<Uniforms>() as u64, .raw
}, .slice(0..std::mem::size_of::<Uniforms>() as u64),
),
}], }],
}); });
let layout = let layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("iced_wgpu::triangle pipeline layout"),
push_constant_ranges: &[],
bind_group_layouts: &[&constants_layout], bind_group_layouts: &[&constants_layout],
}); });
let vs = include_bytes!("shader/triangle.vert.spv"); let vs_module = device.create_shader_module(wgpu::include_spirv!(
let vs_module = device.create_shader_module( "shader/triangle.vert.spv"
&wgpu::read_spirv(std::io::Cursor::new(&vs[..])) ));
.expect("Read triangle vertex shader as SPIR-V"),
);
let fs = include_bytes!("shader/triangle.frag.spv"); let fs_module = device.create_shader_module(wgpu::include_spirv!(
let fs_module = device.create_shader_module( "shader/triangle.frag.spv"
&wgpu::read_spirv(std::io::Cursor::new(&fs[..])) ));
.expect("Read triangle fragment shader as SPIR-V"),
);
let pipeline = let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
layout: &layout, label: Some("iced_wgpu::triangle pipeline"),
layout: Some(&layout),
vertex_stage: wgpu::ProgrammableStageDescriptor { vertex_stage: wgpu::ProgrammableStageDescriptor {
module: &vs_module, module: &vs_module,
entry_point: "main", entry_point: "main",
@ -134,9 +146,7 @@ impl Pipeline {
rasterization_state: Some(wgpu::RasterizationStateDescriptor { rasterization_state: Some(wgpu::RasterizationStateDescriptor {
front_face: wgpu::FrontFace::Cw, front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None, cull_mode: wgpu::CullMode::None,
depth_bias: 0, ..Default::default()
depth_bias_slope_scale: 0.0,
depth_bias_clamp: 0.0,
}), }),
primitive_topology: wgpu::PrimitiveTopology::TriangleList, primitive_topology: wgpu::PrimitiveTopology::TriangleList,
color_states: &[wgpu::ColorStateDescriptor { color_states: &[wgpu::ColorStateDescriptor {
@ -189,11 +199,13 @@ impl Pipeline {
constants: constant_bind_group, constants: constant_bind_group,
uniforms_buffer: constants_buffer, uniforms_buffer: constants_buffer,
vertex_buffer: Buffer::new( vertex_buffer: Buffer::new(
"iced_wgpu::triangle vertex buffer",
device, device,
VERTEX_BUFFER_SIZE, VERTEX_BUFFER_SIZE,
wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST, wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
), ),
index_buffer: Buffer::new( index_buffer: Buffer::new(
"iced_wgpu::triangle index buffer",
device, device,
INDEX_BUFFER_SIZE, INDEX_BUFFER_SIZE,
wgpu::BufferUsage::INDEX | wgpu::BufferUsage::COPY_DST, wgpu::BufferUsage::INDEX | wgpu::BufferUsage::COPY_DST,
@ -204,6 +216,7 @@ impl Pipeline {
pub fn draw( pub fn draw(
&mut self, &mut self,
device: &wgpu::Device, device: &wgpu::Device,
staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder, encoder: &mut wgpu::CommandEncoder,
target: &wgpu::TextureView, target: &wgpu::TextureView,
target_width: u32, target_width: u32,
@ -234,14 +247,15 @@ impl Pipeline {
if self.uniforms_buffer.expand(device, meshes.len()) { if self.uniforms_buffer.expand(device, meshes.len()) {
self.constants = self.constants =
device.create_bind_group(&wgpu::BindGroupDescriptor { device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None, label: Some("iced_wgpu::triangle uniforms buffer"),
layout: &self.constants_layout, layout: &self.constants_layout,
bindings: &[wgpu::Binding { entries: &[wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::Buffer { resource: wgpu::BindingResource::Buffer(
buffer: &self.uniforms_buffer.raw, self.uniforms_buffer.raw.slice(
range: 0..std::mem::size_of::<Uniforms>() as u64, 0..std::mem::size_of::<Uniforms>() as u64,
}, ),
),
}], }],
}); });
} }
@ -261,65 +275,80 @@ impl Pipeline {
* Transformation::translate(mesh.origin.x, mesh.origin.y)) * Transformation::translate(mesh.origin.x, mesh.origin.y))
.into(); .into();
let vertex_buffer = device.create_buffer_with_data( let vertices = bytemuck::cast_slice(&mesh.buffers.vertices);
bytemuck::cast_slice(&mesh.buffers.vertices), let indices = bytemuck::cast_slice(&mesh.buffers.indices);
wgpu::BufferUsage::COPY_SRC,
);
let index_buffer = device.create_buffer_with_data( match (
mesh.buffers.indices.as_bytes(), wgpu::BufferSize::new(vertices.len() as u64),
wgpu::BufferUsage::COPY_SRC, 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,
);
encoder.copy_buffer_to_buffer( vertex_buffer.copy_from_slice(vertices);
&vertex_buffer, }
0,
&self.vertex_buffer.raw,
(std::mem::size_of::<Vertex2D>() * last_vertex) as u64,
(std::mem::size_of::<Vertex2D>() * mesh.buffers.vertices.len())
as u64,
);
encoder.copy_buffer_to_buffer( {
&index_buffer, let mut index_buffer = staging_belt.write_buffer(
0, encoder,
&self.index_buffer.raw, &self.index_buffer.raw,
(std::mem::size_of::<u32>() * last_index) as u64, (std::mem::size_of::<u32>() * last_index) as u64,
(std::mem::size_of::<u32>() * mesh.buffers.indices.len()) indices_size,
as u64, device,
); );
uniforms.push(transform); index_buffer.copy_from_slice(indices);
offsets.push(( }
last_vertex as u64,
last_index as u64,
mesh.buffers.indices.len(),
));
last_vertex += mesh.buffers.vertices.len(); uniforms.push(transform);
last_index += mesh.buffers.indices.len(); 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_buffer = device.create_buffer_with_data( let uniforms = uniforms.as_bytes();
uniforms.as_bytes(),
wgpu::BufferUsage::COPY_SRC,
);
encoder.copy_buffer_to_buffer( if let Some(uniforms_size) =
&uniforms_buffer, wgpu::BufferSize::new(uniforms.len() as u64)
0, {
&self.uniforms_buffer.raw, let mut uniforms_buffer = staging_belt.write_buffer(
0, encoder,
(std::mem::size_of::<Uniforms>() * uniforms.len()) as u64, &self.uniforms_buffer.raw,
); 0,
uniforms_size,
device,
);
uniforms_buffer.copy_from_slice(uniforms);
}
{ {
let (attachment, resolve_target, load_op) = let (attachment, resolve_target, load) =
if let Some(blit) = &mut self.blit { if let Some(blit) = &mut self.blit {
let (attachment, resolve_target) = let (attachment, resolve_target) =
blit.targets(device, target_width, target_height); 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 { } else {
(target, None, wgpu::LoadOp::Load) (target, None, wgpu::LoadOp::Load)
}; };
@ -330,14 +359,7 @@ impl Pipeline {
wgpu::RenderPassColorAttachmentDescriptor { wgpu::RenderPassColorAttachmentDescriptor {
attachment, attachment,
resolve_target, resolve_target,
load_op, ops: wgpu::Operations { load, store: true },
store_op: wgpu::StoreOp::Store,
clear_color: wgpu::Color {
r: 0.0,
g: 0.0,
b: 0.0,
a: 0.0,
},
}, },
], ],
depth_stencil_attachment: None, depth_stencil_attachment: None,
@ -364,16 +386,16 @@ impl Pipeline {
); );
render_pass.set_index_buffer( render_pass.set_index_buffer(
&self.index_buffer.raw, self.index_buffer
index_offset * std::mem::size_of::<u32>() as u64, .raw
0, .slice(index_offset * mem::size_of::<u32>() as u64..),
); );
render_pass.set_vertex_buffer( render_pass.set_vertex_buffer(
0, 0,
&self.vertex_buffer.raw, self.vertex_buffer.raw.slice(
vertex_offset * std::mem::size_of::<Vertex2D>() as u64, vertex_offset * mem::size_of::<Vertex2D>() as u64..,
0, ),
); );
render_pass.draw_indexed(0..indices as u32, 0, 0..1); render_pass.draw_indexed(0..indices as u32, 0, 0..1);

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

@ -23,26 +23,25 @@ impl Blit {
mag_filter: wgpu::FilterMode::Linear, mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear, min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::FilterMode::Linear, mipmap_filter: wgpu::FilterMode::Linear,
lod_min_clamp: -100.0, ..Default::default()
lod_max_clamp: 100.0,
compare: wgpu::CompareFunction::Always,
}); });
let constant_layout = let constant_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None, label: Some("iced_wgpu::triangle:msaa uniforms layout"),
bindings: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT, visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::Sampler { comparison: false }, ty: wgpu::BindingType::Sampler { comparison: false },
count: None,
}], }],
}); });
let constant_bind_group = let constant_bind_group =
device.create_bind_group(&wgpu::BindGroupDescriptor { device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None, label: Some("iced_wgpu::triangle::msaa uniforms bind group"),
layout: &constant_layout, layout: &constant_layout,
bindings: &[wgpu::Binding { entries: &[wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::Sampler(&sampler), resource: wgpu::BindingResource::Sampler(&sampler),
}], }],
@ -50,8 +49,8 @@ impl Blit {
let texture_layout = let texture_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None, label: Some("iced_wgpu::triangle::msaa texture layout"),
bindings: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT, visibility: wgpu::ShaderStage::FRAGMENT,
ty: wgpu::BindingType::SampledTexture { ty: wgpu::BindingType::SampledTexture {
@ -59,29 +58,29 @@ impl Blit {
component_type: wgpu::TextureComponentType::Float, component_type: wgpu::TextureComponentType::Float,
multisampled: false, multisampled: false,
}, },
count: None,
}], }],
}); });
let layout = let layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("iced_wgpu::triangle::msaa pipeline layout"),
push_constant_ranges: &[],
bind_group_layouts: &[&constant_layout, &texture_layout], bind_group_layouts: &[&constant_layout, &texture_layout],
}); });
let vs = include_bytes!("../shader/blit.vert.spv"); let vs_module = device.create_shader_module(wgpu::include_spirv!(
let vs_module = device.create_shader_module( "../shader/blit.vert.spv"
&wgpu::read_spirv(std::io::Cursor::new(&vs[..])) ));
.expect("Read blit vertex shader as SPIR-V"),
);
let fs = include_bytes!("../shader/blit.frag.spv"); let fs_module = device.create_shader_module(wgpu::include_spirv!(
let fs_module = device.create_shader_module( "../shader/blit.frag.spv"
&wgpu::read_spirv(std::io::Cursor::new(&fs[..])) ));
.expect("Read blit fragment shader as SPIR-V"),
);
let pipeline = let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
layout: &layout, label: Some("iced_wgpu::triangle::msaa pipeline"),
layout: Some(&layout),
vertex_stage: wgpu::ProgrammableStageDescriptor { vertex_stage: wgpu::ProgrammableStageDescriptor {
module: &vs_module, module: &vs_module,
entry_point: "main", entry_point: "main",
@ -93,9 +92,7 @@ impl Blit {
rasterization_state: Some(wgpu::RasterizationStateDescriptor { rasterization_state: Some(wgpu::RasterizationStateDescriptor {
front_face: wgpu::FrontFace::Cw, front_face: wgpu::FrontFace::Cw,
cull_mode: wgpu::CullMode::None, cull_mode: wgpu::CullMode::None,
depth_bias: 0, ..Default::default()
depth_bias_slope_scale: 0.0,
depth_bias_clamp: 0.0,
}), }),
primitive_topology: wgpu::PrimitiveTopology::TriangleList, primitive_topology: wgpu::PrimitiveTopology::TriangleList,
color_states: &[wgpu::ColorStateDescriptor { color_states: &[wgpu::ColorStateDescriptor {
@ -179,13 +176,9 @@ impl Blit {
wgpu::RenderPassColorAttachmentDescriptor { wgpu::RenderPassColorAttachmentDescriptor {
attachment: target, attachment: target,
resolve_target: None, resolve_target: None,
load_op: wgpu::LoadOp::Load, ops: wgpu::Operations {
store_op: wgpu::StoreOp::Store, load: wgpu::LoadOp::Load,
clear_color: wgpu::Color { store: true,
r: 0.0,
g: 0.0,
b: 0.0,
a: 0.0,
}, },
}, },
], ],
@ -228,9 +221,8 @@ impl Targets {
}; };
let attachment = device.create_texture(&wgpu::TextureDescriptor { let attachment = device.create_texture(&wgpu::TextureDescriptor {
label: None, label: Some("iced_wgpu::triangle::msaa attachment"),
size: extent, size: extent,
array_layer_count: 1,
mip_level_count: 1, mip_level_count: 1,
sample_count, sample_count,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
@ -239,9 +231,8 @@ impl Targets {
}); });
let resolve = device.create_texture(&wgpu::TextureDescriptor { let resolve = device.create_texture(&wgpu::TextureDescriptor {
label: None, label: Some("iced_wgpu::triangle::msaa resolve target"),
size: extent, size: extent,
array_layer_count: 1,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
@ -250,13 +241,16 @@ impl Targets {
| wgpu::TextureUsage::SAMPLED, | wgpu::TextureUsage::SAMPLED,
}); });
let attachment = attachment.create_default_view(); let attachment =
let resolve = resolve.create_default_view(); attachment.create_view(&wgpu::TextureViewDescriptor::default());
let resolve =
resolve.create_view(&wgpu::TextureViewDescriptor::default());
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None, label: Some("iced_wgpu::triangle::msaa texture bind group"),
layout: texture_layout, layout: texture_layout,
bindings: &[wgpu::Binding { entries: &[wgpu::BindGroupEntry {
binding: 0, binding: 0,
resource: wgpu::BindingResource::TextureView(&resolve), resource: wgpu::BindingResource::TextureView(&resolve),
}], }],

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

@ -1,18 +1,24 @@
use crate::{Backend, Color, Renderer, Settings}; use crate::{Backend, Color, Renderer, Settings};
use futures::task::SpawnExt;
use iced_graphics::Viewport; use iced_graphics::Viewport;
use iced_native::{futures, mouse}; use iced_native::{futures, mouse};
use raw_window_handle::HasRawWindowHandle; use raw_window_handle::HasRawWindowHandle;
/// A window graphics backend for iced powered by `wgpu`. /// A window graphics backend for iced powered by `wgpu`.
#[derive(Debug)] #[allow(missing_debug_implementations)]
pub struct Compositor { pub struct Compositor {
settings: Settings, settings: Settings,
instance: wgpu::Instance,
device: wgpu::Device, device: wgpu::Device,
queue: wgpu::Queue, queue: wgpu::Queue,
staging_belt: wgpu::util::StagingBelt,
local_pool: futures::executor::LocalPool,
} }
impl Compositor { impl Compositor {
const CHUNK_SIZE: u64 = 10 * 1024;
/// Requests a new [`Compositor`] with the given [`Settings`]. /// Requests a new [`Compositor`] with the given [`Settings`].
/// ///
/// Returns `None` if no compatible graphics adapter could be found. /// Returns `None` if no compatible graphics adapter could be found.
@ -20,32 +26,44 @@ impl Compositor {
/// [`Compositor`]: struct.Compositor.html /// [`Compositor`]: struct.Compositor.html
/// [`Settings`]: struct.Settings.html /// [`Settings`]: struct.Settings.html
pub async fn request(settings: Settings) -> Option<Self> { pub async fn request(settings: Settings) -> Option<Self> {
let adapter = wgpu::Adapter::request( let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
&wgpu::RequestAdapterOptions {
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: if settings.antialiasing.is_none() { power_preference: if settings.antialiasing.is_none() {
wgpu::PowerPreference::Default wgpu::PowerPreference::Default
} else { } else {
wgpu::PowerPreference::HighPerformance wgpu::PowerPreference::HighPerformance
}, },
compatible_surface: None, compatible_surface: None,
}, })
wgpu::BackendBit::PRIMARY, .await?;
)
.await?;
let (device, queue) = adapter let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor { .request_device(
extensions: wgpu::Extensions { &wgpu::DeviceDescriptor {
anisotropic_filtering: false, features: wgpu::Features::empty(),
limits: wgpu::Limits {
max_bind_groups: 2,
..wgpu::Limits::default()
},
shader_validation: false,
}, },
limits: wgpu::Limits { max_bind_groups: 2 }, None,
}) )
.await; .await
.ok()?;
let staging_belt = wgpu::util::StagingBelt::new(Self::CHUNK_SIZE);
let local_pool = futures::executor::LocalPool::new();
Some(Compositor { Some(Compositor {
instance,
settings, settings,
device, device,
queue, queue,
staging_belt,
local_pool,
}) })
} }
@ -77,7 +95,10 @@ impl iced_graphics::window::Compositor for Compositor {
&mut self, &mut self,
window: &W, window: &W,
) -> wgpu::Surface { ) -> wgpu::Surface {
wgpu::Surface::create(window) #[allow(unsafe_code)]
unsafe {
self.instance.create_surface(window)
}
} }
fn create_swap_chain( fn create_swap_chain(
@ -107,27 +128,30 @@ impl iced_graphics::window::Compositor for Compositor {
output: &<Self::Renderer as iced_native::Renderer>::Output, output: &<Self::Renderer as iced_native::Renderer>::Output,
overlay: &[T], overlay: &[T],
) -> mouse::Interaction { ) -> mouse::Interaction {
let frame = swap_chain.get_next_texture().expect("Next frame"); let frame = swap_chain.get_current_frame().expect("Next frame");
let mut encoder = self.device.create_command_encoder( let mut encoder = self.device.create_command_encoder(
&wgpu::CommandEncoderDescriptor { label: None }, &wgpu::CommandEncoderDescriptor {
label: Some("iced_wgpu encoder"),
},
); );
let _ = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { let _ = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor { color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view, attachment: &frame.output.view,
resolve_target: None, resolve_target: None,
load_op: wgpu::LoadOp::Clear, ops: wgpu::Operations {
store_op: wgpu::StoreOp::Store, load: wgpu::LoadOp::Clear({
clear_color: { let [r, g, b, a] = background_color.into_linear();
let [r, g, b, a] = background_color.into_linear();
wgpu::Color { wgpu::Color {
r: f64::from(r), r: f64::from(r),
g: f64::from(g), g: f64::from(g),
b: f64::from(b), b: f64::from(b),
a: f64::from(a), a: f64::from(a),
} }
}),
store: true,
}, },
}], }],
depth_stencil_attachment: None, depth_stencil_attachment: None,
@ -135,14 +159,25 @@ impl iced_graphics::window::Compositor for Compositor {
let mouse_interaction = renderer.backend_mut().draw( let mouse_interaction = renderer.backend_mut().draw(
&mut self.device, &mut self.device,
&mut self.staging_belt,
&mut encoder, &mut encoder,
&frame.view, &frame.output.view,
viewport, viewport,
output, output,
overlay, overlay,
); );
self.queue.submit(&[encoder.finish()]); // Submit work
self.staging_belt.finish();
self.queue.submit(Some(encoder.finish()));
// Recall staging buffers
self.local_pool
.spawner()
.spawn(self.staging_belt.recall())
.expect("Recall staging belt");
self.local_pool.run_until_stalled();
mouse_interaction mouse_interaction
} }