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

Merge pull request #1000 from PolyMeilex/wgpu-0.10

Browse source 
wgpu: Update to 0.10
This commit is contained in:
Héctor Ramón 2021-08-25 16:19:00 +07:00 • committed by GitHub
commit 2d65621a3b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 123 additions and 120 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Cargo.toml
View file

@ -10,6 +10,7 @@ documentation = "https://docs.rs/iced"
readme = "README.md" readme = "README.md"
keywords = ["gui", "ui", "graphics", "interface", "widgets"] keywords = ["gui", "ui", "graphics", "interface", "widgets"]
categories = ["gui"] categories = ["gui"]
resolver = "2"
[features] [features]
default = ["wgpu", "default_system_font"] default = ["wgpu", "default_system_font"]

2
examples/integration_wgpu/Cargo.toml
View file

@ -7,5 +7,5 @@ publish = false
[dependencies] [dependencies]
iced_winit = { path = "../../winit" } iced_winit = { path = "../../winit" }
iced_wgpu = { path = "../../wgpu" } iced_wgpu = { path = "../../wgpu", features = ["spirv"] }
env_logger = "0.8" env_logger = "0.8"

34
examples/integration_wgpu/src/main.rs
View file

@ -31,7 +31,7 @@ pub fn main() {
let mut clipboard = Clipboard::connect(&window); let mut clipboard = Clipboard::connect(&window);
// Initialize wgpu // Initialize wgpu
let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY); let instance = wgpu::Instance::new(wgpu::Backends::PRIMARY);
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) };
let (format, (mut device, queue)) = futures::executor::block_on(async { let (format, (mut device, queue)) = futures::executor::block_on(async {
@ -44,8 +44,8 @@ pub fn main() {
.expect("Request adapter"); .expect("Request adapter");
( (
adapter surface
.get_swap_chain_preferred_format(&surface) .get_preferred_format(&adapter)
.expect("Get preferred format"), .expect("Get preferred format"),
adapter adapter
.request_device( .request_device(
@ -61,13 +61,13 @@ pub fn main() {
) )
}); });
let mut swap_chain = { {
let size = window.inner_size(); let size = window.inner_size();
device.create_swap_chain( surface.configure(
&surface, &device,
&wgpu::SwapChainDescriptor { &wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format, format,
width: size.width, width: size.width,
height: size.height, height: size.height,
@ -158,10 +158,10 @@ pub fn main() {
if resized { if resized {
let size = window.inner_size(); let size = window.inner_size();
swap_chain = device.create_swap_chain( surface.configure(
&surface, &device,
&wgpu::SwapChainDescriptor { &wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: format, format: format,
width: size.width, width: size.width,
height: size.height, height: size.height,
@ -172,7 +172,7 @@ pub fn main() {
resized = false; resized = false;
} }
match swap_chain.get_current_frame() { match surface.get_current_frame() {
Ok(frame) => { Ok(frame) => {
let mut encoder = device.create_command_encoder( let mut encoder = device.create_command_encoder(
&wgpu::CommandEncoderDescriptor { label: None }, &wgpu::CommandEncoderDescriptor { label: None },
@ -180,10 +180,12 @@ pub fn main() {
let program = state.program(); let program = state.program();
let view = frame.output.texture.create_view(&wgpu::TextureViewDescriptor::default());
{ {
// We clear the frame // We clear the frame
let mut render_pass = scene.clear( let mut render_pass = scene.clear(
&frame.output.view, &view,
&mut encoder, &mut encoder,
program.background_color(), program.background_color(),
); );
@ -197,7 +199,7 @@ pub fn main() {
&mut device, &mut device,
&mut staging_belt, &mut staging_belt,
&mut encoder, &mut encoder,
&frame.output.view, &view,
&viewport, &viewport,
state.primitive(), state.primitive(),
&debug.overlay(), &debug.overlay(),
@ -223,7 +225,7 @@ pub fn main() {
local_pool.run_until_stalled(); local_pool.run_until_stalled();
} }
Err(error) => match error { Err(error) => match error {
wgpu::SwapChainError::OutOfMemory => { wgpu::SurfaceError::OutOfMemory => {
panic!("Swapchain error: {}. Rendering cannot continue.", error) panic!("Swapchain error: {}. Rendering cannot continue.", error)
} }
_ => { _ => {

2
examples/integration_wgpu/src/scene.rs
View file

@ -79,7 +79,7 @@ fn build_pipeline(device: &wgpu::Device) -> wgpu::RenderPipeline {
color: wgpu::BlendComponent::REPLACE, color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE, alpha: wgpu::BlendComponent::REPLACE,
}), }),
write_mask: wgpu::ColorWrite::ALL, write_mask: wgpu::ColorWrites::ALL,
}], }],
}), }),
primitive: wgpu::PrimitiveState { primitive: wgpu::PrimitiveState {

2
graphics/src/window.rs
View file

@ -4,7 +4,7 @@ mod compositor;
#[cfg(feature = "opengl")] #[cfg(feature = "opengl")]
mod gl_compositor; mod gl_compositor;
pub use compositor::{Compositor, SwapChainError}; pub use compositor::{Compositor, SurfaceError};
#[cfg(feature = "opengl")] #[cfg(feature = "opengl")]
pub use gl_compositor::GLCompositor; pub use gl_compositor::GLCompositor;

15
graphics/src/window/compositor.rs
View file

@ -16,9 +16,6 @@ pub trait Compositor: Sized {
/// The surface of the backend. /// The surface of the backend.
type Surface; type Surface;
/// The swap chain of the backend.
type SwapChain;
/// Creates a new [`Compositor`]. /// Creates a new [`Compositor`].
fn new<W: HasRawWindowHandle>( fn new<W: HasRawWindowHandle>(
settings: Self::Settings, settings: Self::Settings,
@ -37,12 +34,12 @@ pub trait Compositor: Sized {
/// ///
/// [`SwapChain`]: Self::SwapChain /// [`SwapChain`]: Self::SwapChain
/// [`Surface`]: Self::Surface /// [`Surface`]: Self::Surface
fn create_swap_chain( fn configure_surface(
&mut self, &mut self,
surface: &Self::Surface, surface: &mut Self::Surface,
width: u32, width: u32,
height: u32, height: u32,
) -> Self::SwapChain; );
/// Draws the output primitives to the next frame of the given [`SwapChain`]. /// Draws the output primitives to the next frame of the given [`SwapChain`].
/// ///
@ -50,17 +47,17 @@ pub trait Compositor: Sized {
fn draw<T: AsRef<str>>( fn draw<T: AsRef<str>>(
&mut self, &mut self,
renderer: &mut Self::Renderer, renderer: &mut Self::Renderer,
swap_chain: &mut Self::SwapChain, surface: &mut Self::Surface,
viewport: &Viewport, viewport: &Viewport,
background_color: Color, background_color: Color,
output: &<Self::Renderer as iced_native::Renderer>::Output, output: &<Self::Renderer as iced_native::Renderer>::Output,
overlay: &[T], overlay: &[T],
) -> Result<mouse::Interaction, SwapChainError>; ) -> Result<mouse::Interaction, SurfaceError>;
} }
/// Result of an unsuccessful call to [`Compositor::draw`]. /// Result of an unsuccessful call to [`Compositor::draw`].
#[derive(Clone, PartialEq, Eq, Debug, Error)] #[derive(Clone, PartialEq, Eq, Debug, Error)]
pub enum SwapChainError { pub enum SurfaceError {
/// A timeout was encountered while trying to acquire the next frame. /// A timeout was encountered while trying to acquire the next frame.
#[error( #[error(
"A timeout was encountered while trying to acquire the next frame" "A timeout was encountered while trying to acquire the next frame"

5
wgpu/Cargo.toml
View file

@ -24,10 +24,11 @@ farbfeld = ["image_rs/farbfeld"]
canvas = ["iced_graphics/canvas"] canvas = ["iced_graphics/canvas"]
qr_code = ["iced_graphics/qr_code"] qr_code = ["iced_graphics/qr_code"]
default_system_font = ["iced_graphics/font-source"] default_system_font = ["iced_graphics/font-source"]
spirv = ["wgpu/spirv"]
[dependencies] [dependencies]
wgpu = "0.9" wgpu = "0.10"
wgpu_glyph = "0.13" wgpu_glyph = "0.14"
glyph_brush = "0.7" glyph_brush = "0.7"
raw-window-handle = "0.3" raw-window-handle = "0.3"
log = "0.4" log = "0.4"

21
wgpu/src/image.rs
View file

@ -61,7 +61,7 @@ impl Pipeline {
entries: &[ entries: &[
wgpu::BindGroupLayoutEntry { wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::VERTEX, visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer { ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform, ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false, has_dynamic_offset: false,
@ -73,7 +73,7 @@ impl Pipeline {
}, },
wgpu::BindGroupLayoutEntry { wgpu::BindGroupLayoutEntry {
binding: 1, binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT, visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler { ty: wgpu::BindingType::Sampler {
comparison: false, comparison: false,
filtering: true, filtering: true,
@ -86,7 +86,7 @@ impl Pipeline {
let uniforms_buffer = device.create_buffer(&wgpu::BufferDescriptor { let uniforms_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("iced_wgpu::image uniforms buffer"), label: Some("iced_wgpu::image uniforms buffer"),
size: mem::size_of::<Uniforms>() as u64, size: mem::size_of::<Uniforms>() as u64,
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST, usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false, mapped_at_creation: false,
}); });
@ -117,7 +117,7 @@ impl Pipeline {
label: Some("iced_wgpu::image texture atlas layout"), label: Some("iced_wgpu::image texture atlas layout"),
entries: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT, visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture { ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { sample_type: wgpu::TextureSampleType::Float {
filterable: true, filterable: true,
@ -142,7 +142,6 @@ impl Pipeline {
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed( source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
include_str!("shader/image.wgsl"), include_str!("shader/image.wgsl"),
)), )),
flags: wgpu::ShaderFlags::all(),
}); });
let pipeline = let pipeline =
@ -155,7 +154,7 @@ impl Pipeline {
buffers: &[ buffers: &[
wgpu::VertexBufferLayout { wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Vertex>() as u64, array_stride: mem::size_of::<Vertex>() as u64,
step_mode: wgpu::InputStepMode::Vertex, step_mode: wgpu::VertexStepMode::Vertex,
attributes: &[wgpu::VertexAttribute { attributes: &[wgpu::VertexAttribute {
shader_location: 0, shader_location: 0,
format: wgpu::VertexFormat::Float32x2, format: wgpu::VertexFormat::Float32x2,
@ -164,7 +163,7 @@ impl Pipeline {
}, },
wgpu::VertexBufferLayout { wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Instance>() as u64, array_stride: mem::size_of::<Instance>() as u64,
step_mode: wgpu::InputStepMode::Instance, step_mode: wgpu::VertexStepMode::Instance,
attributes: &wgpu::vertex_attr_array!( attributes: &wgpu::vertex_attr_array!(
1 => Float32x2, 1 => Float32x2,
2 => Float32x2, 2 => Float32x2,
@ -192,7 +191,7 @@ impl Pipeline {
operation: wgpu::BlendOperation::Add, operation: wgpu::BlendOperation::Add,
}, },
}), }),
write_mask: wgpu::ColorWrite::ALL, write_mask: wgpu::ColorWrites::ALL,
}], }],
}), }),
primitive: wgpu::PrimitiveState { primitive: wgpu::PrimitiveState {
@ -212,20 +211,20 @@ impl Pipeline {
device.create_buffer_init(&wgpu::util::BufferInitDescriptor { device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("iced_wgpu::image vertex buffer"), label: Some("iced_wgpu::image vertex buffer"),
contents: bytemuck::cast_slice(&QUAD_VERTS), contents: bytemuck::cast_slice(&QUAD_VERTS),
usage: wgpu::BufferUsage::VERTEX, usage: wgpu::BufferUsages::VERTEX,
}); });
let indices = let indices =
device.create_buffer_init(&wgpu::util::BufferInitDescriptor { device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("iced_wgpu::image index buffer"), label: Some("iced_wgpu::image index buffer"),
contents: bytemuck::cast_slice(&QUAD_INDICES), contents: bytemuck::cast_slice(&QUAD_INDICES),
usage: wgpu::BufferUsage::INDEX, usage: wgpu::BufferUsages::INDEX,
}); });
let instances = device.create_buffer(&wgpu::BufferDescriptor { let instances = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("iced_wgpu::image instance buffer"), 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::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false, mapped_at_creation: false,
}); });

17
wgpu/src/image/atlas.rs
View file

@ -36,9 +36,9 @@ impl Atlas {
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Bgra8UnormSrgb, format: wgpu::TextureFormat::Bgra8UnormSrgb,
usage: wgpu::TextureUsage::COPY_DST usage: wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsage::COPY_SRC | wgpu::TextureUsages::COPY_SRC
| wgpu::TextureUsage::SAMPLED, | wgpu::TextureUsages::TEXTURE_BINDING,
}); });
let texture_view = texture.create_view(&wgpu::TextureViewDescriptor { let texture_view = texture.create_view(&wgpu::TextureViewDescriptor {
@ -107,7 +107,7 @@ impl Atlas {
device.create_buffer_init(&wgpu::util::BufferInitDescriptor { device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("iced_wgpu::image staging buffer"), label: Some("iced_wgpu::image staging buffer"),
contents: &padded_data, contents: &padded_data,
usage: wgpu::BufferUsage::COPY_SRC, usage: wgpu::BufferUsages::COPY_SRC,
}); });
match &entry { match &entry {
@ -316,6 +316,7 @@ impl Atlas {
y, y,
z: layer as u32, z: layer as u32,
}, },
aspect: wgpu::TextureAspect::default(),
}, },
extent, extent,
); );
@ -342,9 +343,9 @@ impl Atlas {
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Bgra8UnormSrgb, format: wgpu::TextureFormat::Bgra8UnormSrgb,
usage: wgpu::TextureUsage::COPY_DST usage: wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsage::COPY_SRC | wgpu::TextureUsages::COPY_SRC
| wgpu::TextureUsage::SAMPLED, | wgpu::TextureUsages::TEXTURE_BINDING,
}); });
let amount_to_copy = self.layers.len() - amount; let amount_to_copy = self.layers.len() - amount;
@ -365,6 +366,7 @@ impl Atlas {
y: 0, y: 0,
z: i as u32, z: i as u32,
}, },
aspect: wgpu::TextureAspect::default(),
}, },
wgpu::ImageCopyTexture { wgpu::ImageCopyTexture {
texture: &new_texture, texture: &new_texture,
@ -374,6 +376,7 @@ impl Atlas {
y: 0, y: 0,
z: i as u32, z: i as u32,
}, },
aspect: wgpu::TextureAspect::default(),
}, },
wgpu::Extent3d { wgpu::Extent3d {
width: SIZE, width: SIZE,

17
wgpu/src/quad.rs
View file

@ -23,7 +23,7 @@ impl Pipeline {
label: Some("iced_wgpu::quad uniforms layout"), label: Some("iced_wgpu::quad uniforms layout"),
entries: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::VERTEX, visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer { ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform, ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false, has_dynamic_offset: false,
@ -38,7 +38,7 @@ impl Pipeline {
let constants_buffer = device.create_buffer(&wgpu::BufferDescriptor { let constants_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("iced_wgpu::quad uniforms buffer"), label: Some("iced_wgpu::quad uniforms buffer"),
size: mem::size_of::<Uniforms>() as wgpu::BufferAddress, size: mem::size_of::<Uniforms>() as wgpu::BufferAddress,
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST, usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false, mapped_at_creation: false,
}); });
@ -64,7 +64,6 @@ impl Pipeline {
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed( source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
include_str!("shader/quad.wgsl"), include_str!("shader/quad.wgsl"),
)), )),
flags: wgpu::ShaderFlags::all(),
}); });
let pipeline = let pipeline =
@ -77,7 +76,7 @@ impl Pipeline {
buffers: &[ buffers: &[
wgpu::VertexBufferLayout { wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Vertex>() as u64, array_stride: mem::size_of::<Vertex>() as u64,
step_mode: wgpu::InputStepMode::Vertex, step_mode: wgpu::VertexStepMode::Vertex,
attributes: &[wgpu::VertexAttribute { attributes: &[wgpu::VertexAttribute {
shader_location: 0, shader_location: 0,
format: wgpu::VertexFormat::Float32x2, format: wgpu::VertexFormat::Float32x2,
@ -86,7 +85,7 @@ impl Pipeline {
}, },
wgpu::VertexBufferLayout { wgpu::VertexBufferLayout {
array_stride: mem::size_of::<layer::Quad>() as u64, array_stride: mem::size_of::<layer::Quad>() as u64,
step_mode: wgpu::InputStepMode::Instance, step_mode: wgpu::VertexStepMode::Instance,
attributes: &wgpu::vertex_attr_array!( attributes: &wgpu::vertex_attr_array!(
1 => Float32x2, 1 => Float32x2,
2 => Float32x2, 2 => Float32x2,
@ -115,7 +114,7 @@ impl Pipeline {
operation: wgpu::BlendOperation::Add, operation: wgpu::BlendOperation::Add,
}, },
}), }),
write_mask: wgpu::ColorWrite::ALL, write_mask: wgpu::ColorWrites::ALL,
}], }],
}), }),
primitive: wgpu::PrimitiveState { primitive: wgpu::PrimitiveState {
@ -135,20 +134,20 @@ impl Pipeline {
device.create_buffer_init(&wgpu::util::BufferInitDescriptor { device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("iced_wgpu::quad vertex buffer"), label: Some("iced_wgpu::quad vertex buffer"),
contents: bytemuck::cast_slice(&QUAD_VERTS), contents: bytemuck::cast_slice(&QUAD_VERTS),
usage: wgpu::BufferUsage::VERTEX, usage: wgpu::BufferUsages::VERTEX,
}); });
let indices = let indices =
device.create_buffer_init(&wgpu::util::BufferInitDescriptor { device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("iced_wgpu::quad index buffer"), label: Some("iced_wgpu::quad index buffer"),
contents: bytemuck::cast_slice(&QUAD_INDICES), contents: bytemuck::cast_slice(&QUAD_INDICES),
usage: wgpu::BufferUsage::INDEX, usage: wgpu::BufferUsages::INDEX,
}); });
let instances = device.create_buffer(&wgpu::BufferDescriptor { let instances = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("iced_wgpu::quad instance buffer"), 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::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false, mapped_at_creation: false,
}); });

22
wgpu/src/settings.rs
View file

@ -12,7 +12,7 @@ pub struct Settings {
pub present_mode: wgpu::PresentMode, pub present_mode: wgpu::PresentMode,
/// The internal graphics backend to use. /// The internal graphics backend to use.
pub internal_backend: wgpu::BackendBit, pub internal_backend: wgpu::Backends,
/// The bytes of the font that will be used by default. /// The bytes of the font that will be used by default.
/// ///
@ -54,7 +54,7 @@ impl Settings {
pub fn from_env() -> Self { pub fn from_env() -> Self {
Settings { Settings {
internal_backend: backend_from_env() internal_backend: backend_from_env()
.unwrap_or(wgpu::BackendBit::PRIMARY), .unwrap_or(wgpu::Backends::all()),
..Self::default() ..Self::default()
} }
} }
@ -64,7 +64,7 @@ impl Default for Settings {
fn default() -> Settings { fn default() -> Settings {
Settings { Settings {
present_mode: wgpu::PresentMode::Mailbox, present_mode: wgpu::PresentMode::Mailbox,
internal_backend: wgpu::BackendBit::PRIMARY, internal_backend: wgpu::Backends::all(),
default_font: None, default_font: None,
default_text_size: 20, default_text_size: 20,
text_multithreading: false, text_multithreading: false,
@ -73,16 +73,16 @@ impl Default for Settings {
} }
} }
fn backend_from_env() -> Option<wgpu::BackendBit> { fn backend_from_env() -> Option<wgpu::Backends> {
std::env::var("WGPU_BACKEND").ok().map(|backend| { std::env::var("WGPU_BACKEND").ok().map(|backend| {
match backend.to_lowercase().as_str() { match backend.to_lowercase().as_str() {
"vulkan" => wgpu::BackendBit::VULKAN, "vulkan" => wgpu::Backends::VULKAN,
"metal" => wgpu::BackendBit::METAL, "metal" => wgpu::Backends::METAL,
"dx12" => wgpu::BackendBit::DX12, "dx12" => wgpu::Backends::DX12,
"dx11" => wgpu::BackendBit::DX11, "dx11" => wgpu::Backends::DX11,
"gl" => wgpu::BackendBit::GL, "gl" => wgpu::Backends::GL,
"webgpu" => wgpu::BackendBit::BROWSER_WEBGPU, "webgpu" => wgpu::Backends::BROWSER_WEBGPU,
"primary" => wgpu::BackendBit::PRIMARY, "primary" => wgpu::Backends::PRIMARY,
other => panic!("Unknown backend: {}", other), other => panic!("Unknown backend: {}", other),
} }
}) })

17
wgpu/src/triangle.rs
View file

@ -29,7 +29,7 @@ struct Buffer<T> {
label: &'static str, label: &'static str,
raw: wgpu::Buffer, raw: wgpu::Buffer,
size: usize, size: usize,
usage: wgpu::BufferUsage, usage: wgpu::BufferUsages,
_type: std::marker::PhantomData<T>, _type: std::marker::PhantomData<T>,
} }
@ -38,7 +38,7 @@ impl<T> Buffer<T> {
label: &'static str, label: &'static str,
device: &wgpu::Device, device: &wgpu::Device,
size: usize, size: usize,
usage: wgpu::BufferUsage, usage: wgpu::BufferUsages,
) -> Self { ) -> Self {
let raw = device.create_buffer(&wgpu::BufferDescriptor { let raw = device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label), label: Some(label),
@ -85,7 +85,7 @@ impl Pipeline {
label: Some("iced_wgpu::triangle uniforms layout"), label: Some("iced_wgpu::triangle uniforms layout"),
entries: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::VERTEX, visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer { ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform, ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true, has_dynamic_offset: true,
@ -101,7 +101,7 @@ impl Pipeline {
"iced_wgpu::triangle uniforms buffer", "iced_wgpu::triangle uniforms buffer",
device, device,
UNIFORM_BUFFER_SIZE, UNIFORM_BUFFER_SIZE,
wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST, wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
); );
let constant_bind_group = let constant_bind_group =
@ -137,7 +137,6 @@ impl Pipeline {
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed( source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
include_str!("shader/triangle.wgsl"), include_str!("shader/triangle.wgsl"),
)), )),
flags: wgpu::ShaderFlags::all(),
}); });
let pipeline = let pipeline =
@ -149,7 +148,7 @@ impl Pipeline {
entry_point: "vs_main", entry_point: "vs_main",
buffers: &[wgpu::VertexBufferLayout { buffers: &[wgpu::VertexBufferLayout {
array_stride: mem::size_of::<Vertex2D>() as u64, array_stride: mem::size_of::<Vertex2D>() as u64,
step_mode: wgpu::InputStepMode::Vertex, step_mode: wgpu::VertexStepMode::Vertex,
attributes: &wgpu::vertex_attr_array!( attributes: &wgpu::vertex_attr_array!(
// Position // Position
0 => Float32x2, 0 => Float32x2,
@ -175,7 +174,7 @@ impl Pipeline {
operation: wgpu::BlendOperation::Add, operation: wgpu::BlendOperation::Add,
}, },
}), }),
write_mask: wgpu::ColorWrite::ALL, write_mask: wgpu::ColorWrites::ALL,
}], }],
}), }),
primitive: wgpu::PrimitiveState { primitive: wgpu::PrimitiveState {
@ -203,13 +202,13 @@ impl Pipeline {
"iced_wgpu::triangle vertex buffer", "iced_wgpu::triangle vertex buffer",
device, device,
VERTEX_BUFFER_SIZE, VERTEX_BUFFER_SIZE,
wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST, wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
), ),
index_buffer: Buffer::new( index_buffer: Buffer::new(
"iced_wgpu::triangle index buffer", "iced_wgpu::triangle index buffer",
device, device,
INDEX_BUFFER_SIZE, INDEX_BUFFER_SIZE,
wgpu::BufferUsage::INDEX | wgpu::BufferUsage::COPY_DST, wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
), ),
} }
} }

13
wgpu/src/triangle/msaa.rs
View file

@ -31,7 +31,7 @@ impl Blit {
label: Some("iced_wgpu::triangle:msaa uniforms layout"), label: Some("iced_wgpu::triangle:msaa uniforms layout"),
entries: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT, visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler { ty: wgpu::BindingType::Sampler {
comparison: false, comparison: false,
filtering: false, filtering: false,
@ -55,7 +55,7 @@ impl Blit {
label: Some("iced_wgpu::triangle::msaa texture layout"), label: Some("iced_wgpu::triangle::msaa texture layout"),
entries: &[wgpu::BindGroupLayoutEntry { entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT, visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture { ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { sample_type: wgpu::TextureSampleType::Float {
filterable: false, filterable: false,
@ -80,7 +80,6 @@ impl Blit {
source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed( source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
include_str!("../shader/blit.wgsl"), include_str!("../shader/blit.wgsl"),
)), )),
flags: wgpu::ShaderFlags::all(),
}); });
let pipeline = let pipeline =
@ -109,7 +108,7 @@ impl Blit {
operation: wgpu::BlendOperation::Add, operation: wgpu::BlendOperation::Add,
}, },
}), }),
write_mask: wgpu::ColorWrite::ALL, write_mask: wgpu::ColorWrites::ALL,
}], }],
}), }),
primitive: wgpu::PrimitiveState { primitive: wgpu::PrimitiveState {
@ -232,7 +231,7 @@ impl Targets {
sample_count, sample_count,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format, format,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
}); });
let resolve = device.create_texture(&wgpu::TextureDescriptor { let resolve = device.create_texture(&wgpu::TextureDescriptor {
@ -242,8 +241,8 @@ impl Targets {
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format, format,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT usage: wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsage::SAMPLED, | wgpu::TextureUsages::TEXTURE_BINDING,
}); });
let attachment = let attachment =

50
wgpu/src/window/compositor.rs
View file

@ -45,7 +45,7 @@ impl Compositor {
let format = compatible_surface let format = compatible_surface
.as_ref() .as_ref()
.and_then(|surf| adapter.get_swap_chain_preferred_format(surf))?; .and_then(|surface| surface.get_preferred_format(&adapter))?;
let (device, queue) = adapter let (device, queue) = adapter
.request_device( .request_device(
@ -88,7 +88,6 @@ impl iced_graphics::window::Compositor for Compositor {
type Settings = Settings; type Settings = Settings;
type Renderer = Renderer; type Renderer = Renderer;
type Surface = wgpu::Surface; type Surface = wgpu::Surface;
type SwapChain = wgpu::SwapChain;
fn new<W: HasRawWindowHandle>( fn new<W: HasRawWindowHandle>(
settings: Self::Settings, settings: Self::Settings,
@ -115,34 +114,34 @@ impl iced_graphics::window::Compositor for Compositor {
} }
} }
fn create_swap_chain( fn configure_surface(
&mut self, &mut self,
surface: &Self::Surface, surface: &mut Self::Surface,
width: u32, width: u32,
height: u32, height: u32,
) -> Self::SwapChain { ) {
self.device.create_swap_chain( surface.configure(
surface, &self.device,
&wgpu::SwapChainDescriptor { &wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: self.format, format: self.format,
present_mode: self.settings.present_mode, present_mode: self.settings.present_mode,
width, width,
height, height,
}, },
) );
} }
fn draw<T: AsRef<str>>( fn draw<T: AsRef<str>>(
&mut self, &mut self,
renderer: &mut Self::Renderer, renderer: &mut Self::Renderer,
swap_chain: &mut Self::SwapChain, surface: &mut Self::Surface,
viewport: &Viewport, viewport: &Viewport,
background_color: Color, background_color: Color,
output: &<Self::Renderer as iced_native::Renderer>::Output, output: &<Self::Renderer as iced_native::Renderer>::Output,
overlay: &[T], overlay: &[T],
) -> Result<mouse::Interaction, iced_graphics::window::SwapChainError> { ) -> Result<mouse::Interaction, iced_graphics::window::SurfaceError> {
match swap_chain.get_current_frame() { match surface.get_current_frame() {
Ok(frame) => { Ok(frame) => {
let mut encoder = self.device.create_command_encoder( let mut encoder = self.device.create_command_encoder(
&wgpu::CommandEncoderDescriptor { &wgpu::CommandEncoderDescriptor {
@ -150,13 +149,18 @@ impl iced_graphics::window::Compositor for Compositor {
}, },
); );
let view = &frame
.output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let _ = let _ =
encoder.begin_render_pass(&wgpu::RenderPassDescriptor { encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some( label: Some(
"iced_wgpu::window::Compositor render pass", "iced_wgpu::window::Compositor render pass",
), ),
color_attachments: &[wgpu::RenderPassColorAttachment { color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.output.view, view,
resolve_target: None, resolve_target: None,
ops: wgpu::Operations { ops: wgpu::Operations {
load: wgpu::LoadOp::Clear({ load: wgpu::LoadOp::Clear({
@ -180,7 +184,7 @@ impl iced_graphics::window::Compositor for Compositor {
&mut self.device, &mut self.device,
&mut self.staging_belt, &mut self.staging_belt,
&mut encoder, &mut encoder,
&frame.output.view, view,
viewport, viewport,
output, output,
overlay, overlay,
@ -201,17 +205,17 @@ impl iced_graphics::window::Compositor for Compositor {
Ok(mouse_interaction) Ok(mouse_interaction)
} }
Err(error) => match error { Err(error) => match error {
wgpu::SwapChainError::Timeout => { wgpu::SurfaceError::Timeout => {
Err(iced_graphics::window::SwapChainError::Timeout) Err(iced_graphics::window::SurfaceError::Timeout)
} }
wgpu::SwapChainError::Outdated => { wgpu::SurfaceError::Outdated => {
Err(iced_graphics::window::SwapChainError::Outdated) Err(iced_graphics::window::SurfaceError::Outdated)
} }
wgpu::SwapChainError::Lost => { wgpu::SurfaceError::Lost => {
Err(iced_graphics::window::SwapChainError::Lost) Err(iced_graphics::window::SurfaceError::Lost)
} }
wgpu::SwapChainError::OutOfMemory => { wgpu::SurfaceError::OutOfMemory => {
Err(iced_graphics::window::SwapChainError::OutOfMemory) Err(iced_graphics::window::SurfaceError::OutOfMemory)
} }
}, },
} }

25
winit/src/application.rs
View file

@ -227,20 +227,19 @@ async fn run_instance<A, E, C>(
use iced_futures::futures::stream::StreamExt; use iced_futures::futures::stream::StreamExt;
use winit::event; use winit::event;
let surface = compositor.create_surface(&window); let mut surface = compositor.create_surface(&window);
let mut clipboard = Clipboard::connect(&window); let mut clipboard = Clipboard::connect(&window);
let mut state = State::new(&application, &window); let mut state = State::new(&application, &window);
let mut viewport_version = state.viewport_version(); let mut viewport_version = state.viewport_version();
let mut swap_chain = {
let physical_size = state.physical_size();
compositor.create_swap_chain( let physical_size = state.physical_size();
&surface,
physical_size.width, compositor.configure_surface(
physical_size.height, &mut surface,
) physical_size.width,
}; physical_size.height,
);
let mut user_interface = ManuallyDrop::new(build_user_interface( let mut user_interface = ManuallyDrop::new(build_user_interface(
&mut application, &mut application,
@ -358,8 +357,8 @@ async fn run_instance<A, E, C>(
.draw(&mut renderer, state.cursor_position()); .draw(&mut renderer, state.cursor_position());
debug.draw_finished(); debug.draw_finished();
swap_chain = compositor.create_swap_chain( compositor.configure_surface(
&surface, &mut surface,
physical_size.width, physical_size.width,
physical_size.height, physical_size.height,
); );
@ -369,7 +368,7 @@ async fn run_instance<A, E, C>(
match compositor.draw( match compositor.draw(
&mut renderer, &mut renderer,
&mut swap_chain, &mut surface,
state.viewport(), state.viewport(),
state.background_color(), state.background_color(),
&primitive, &primitive,
@ -393,7 +392,7 @@ async fn run_instance<A, E, C>(
} }
Err(error) => match error { Err(error) => match error {
// This is an unrecoverable error. // This is an unrecoverable error.
window::SwapChainError::OutOfMemory => { window::SurfaceError::OutOfMemory => {
panic!("{}", error); panic!("{}", error);
} }
_ => { _ => {