Archives
/
learn-wgpu
mirror of https://github.com/sotrh/learn-wgpu
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

code now builds on 0.8

Browse Source
pull/177/head
Ben Hansen 3 years ago
parent e0cd2b0a39
commit 46eb5eb139
81 changed files with 733 additions and 1816 deletions
Show Stats Download Patch File Download Diff File

1524
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

4
Cargo.toml
Unescape Escape View File

@ -8,4 +8,8 @@ members = [
# showcase
"code/showcase/*",
]
exclude = [
"code/showcase/imgui-demo",
"code/showcase/pong",
]

4
code/beginner/tutorial1-window/Cargo.toml
Unescape Escape View File

@ -16,7 +16,7 @@ image = "0.23"
winit = "0.24"
shaderc = "0.7"
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
log = "0.4"
wgpu = "0.7"
wgpu = "0.8"
futures = "0.3"

4
code/beginner/tutorial2-swapchain/Cargo.toml
Unescape Escape View File

@ -11,9 +11,9 @@ image = "0.23"
winit = "0.24"
shaderc = "0.7"
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
log = "0.4"
wgpu = "0.7"
wgpu = "0.8"
futures = "0.3"

6
code/beginner/tutorial2-swapchain/src/challenge.rs
Unescape Escape View File

@ -46,7 +46,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -104,8 +104,8 @@ impl State {
{
let _render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(self.clear_color),

6
code/beginner/tutorial2-swapchain/src/main.rs
Unescape Escape View File

@ -45,7 +45,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -88,8 +88,8 @@ impl State {
{
let _render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

4
code/beginner/tutorial3-pipeline/Cargo.toml
Unescape Escape View File

@ -9,9 +9,9 @@ image = "0.23"
winit = "0.24"
# shaderc = "0.7" # REMOVED!
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
log = "0.4"
wgpu = "0.7"
wgpu = "0.8"
futures = "0.3"
# NEW!

24
code/beginner/tutorial3-pipeline/src/challenge.rs
Unescape Escape View File

@ -48,7 +48,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -78,8 +78,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -87,9 +89,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -116,8 +122,7 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
color_blend: wgpu::BlendState::REPLACE,
alpha_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState::REPLACE),
write_mask: wgpu::ColorWrite::ALL,
}]
}),
@ -125,9 +130,10 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
..Default::default()
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -191,8 +197,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

16
code/beginner/tutorial3-pipeline/src/main.rs
Unescape Escape View File

@ -77,8 +77,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -86,9 +88,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -135,8 +141,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

4
code/beginner/tutorial4-buffer/Cargo.toml
Unescape Escape View File

@ -9,8 +9,8 @@ edition = "2018"
image = "0.23"
cgmath = "0.18"
winit = "0.24"
wgpu = "0.7"
env_logger = "0.7"
wgpu = "0.8"
env_logger = "0.8"
log = "0.4"
futures = "0.3"
# NEW!

22
code/beginner/tutorial4-buffer/src/challenge.rs
Unescape Escape View File

@ -23,12 +23,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}
@ -111,7 +111,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -141,8 +141,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -150,9 +152,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -264,8 +270,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

22
code/beginner/tutorial4-buffer/src/main.rs
Unescape Escape View File

@ -23,12 +23,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}
@ -104,7 +104,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -134,8 +134,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -143,9 +145,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -207,8 +213,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

4
code/beginner/tutorial5-textures/Cargo.toml
Unescape Escape View File

@ -10,11 +10,11 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
log = "0.4"
futures = "0.3"
image = "0.23"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

22
code/beginner/tutorial5-textures/src/challenge.rs
Unescape Escape View File

@ -26,12 +26,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
@ -112,7 +112,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -207,8 +207,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -216,9 +218,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -298,8 +304,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

22
code/beginner/tutorial5-textures/src/main.rs
Unescape Escape View File

@ -26,12 +26,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
@ -109,7 +109,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -184,8 +184,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -193,9 +195,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -259,8 +265,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

12
code/beginner/tutorial5-textures/src/texture.rs
Unescape Escape View File

@ -1,3 +1,5 @@
use std::num::NonZeroU32;
use anyhow::*;
use image::GenericImageView;
@ -30,7 +32,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -43,16 +45,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/beginner/tutorial6-uniforms/Cargo.toml
Unescape Escape View File

@ -8,11 +8,11 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
log = "0.4"
futures = "0.3"
image = "0.23"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

22
code/beginner/tutorial6-uniforms/src/challenge.rs
Unescape Escape View File

@ -26,12 +26,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
@ -274,7 +274,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -394,8 +394,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -403,9 +405,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -485,8 +491,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

22
code/beginner/tutorial6-uniforms/src/main.rs
Unescape Escape View File

@ -26,12 +26,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
@ -259,7 +259,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -378,8 +378,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -387,9 +389,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -467,8 +473,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

12
code/beginner/tutorial6-uniforms/src/texture.rs
Unescape Escape View File

@ -1,3 +1,5 @@
use std::num::NonZeroU32;
use anyhow::*;
use image::GenericImageView;
@ -30,7 +32,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -43,16 +45,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/beginner/tutorial7-instancing/Cargo.toml
Unescape Escape View File

@ -8,11 +8,11 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
log = "0.4"
futures = "0.3"
image = "0.23"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

30
code/beginner/tutorial7-instancing/src/challenge.rs
Unescape Escape View File

@ -27,12 +27,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
@ -252,24 +252,24 @@ impl InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -356,7 +356,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -510,8 +510,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -519,9 +521,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -617,8 +623,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

30
code/beginner/tutorial7-instancing/src/main.rs
Unescape Escape View File

@ -34,12 +34,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
@ -242,24 +242,24 @@ impl InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -320,7 +320,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -474,8 +474,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -483,9 +485,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -566,8 +572,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {

12
code/beginner/tutorial7-instancing/src/texture.rs
Unescape Escape View File

@ -1,3 +1,5 @@
use std::num::NonZeroU32;
use anyhow::*;
use image::GenericImageView;
@ -30,7 +32,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -43,16 +45,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/beginner/tutorial8-depth/Cargo.toml
Unescape Escape View File

@ -8,11 +8,11 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
futures = "0.3"
image = "0.23"
log = "0.4"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

52
code/beginner/tutorial8-depth/src/challenge.rs
Unescape Escape View File

@ -27,12 +27,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
@ -273,24 +273,24 @@ impl InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -384,8 +384,10 @@ impl DepthPass {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -393,9 +395,13 @@ impl DepthPass {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -437,8 +443,8 @@ impl DepthPass {
fn render(&self, frame: &wgpu::SwapChainTexture, encoder: &mut wgpu::CommandEncoder) {
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Depth Visual Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Load,
@ -509,7 +515,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -663,8 +669,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -672,9 +680,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: Some(wgpu::DepthStencilState {
format: texture::Texture::DEPTH_FORMAT,
@ -686,8 +698,6 @@ impl State {
slope_scale: 2.0,
clamp: 0.0,
},
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,
@ -771,8 +781,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -784,8 +794,8 @@ impl State {
store: true,
},
}],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_pass.texture.view,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &self.depth_pass.texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

36
code/beginner/tutorial8-depth/src/main.rs
Unescape Escape View File

@ -27,12 +27,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
],
}
@ -251,24 +251,24 @@ impl InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -330,7 +330,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -487,8 +487,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -496,9 +498,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: Some(wgpu::DepthStencilState {
format: texture::Texture::DEPTH_FORMAT,
@ -506,8 +512,6 @@ impl State {
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,
@ -589,8 +593,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -602,8 +606,8 @@ impl State {
store: true,
},
}],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_texture.view,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &self.depth_texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

14
code/beginner/tutorial8-depth/src/texture.rs
Unescape Escape View File

@ -1,3 +1,5 @@
use std::num::NonZeroU32;
use anyhow::*;
use image::GenericImageView;
@ -18,7 +20,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
label: Some(label),
@ -73,7 +75,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -86,16 +88,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/beginner/tutorial9-models/Cargo.toml
Unescape Escape View File

@ -8,12 +8,12 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
futures = "0.3"
image = "0.23"
log = "0.4"
tobj = "2.0"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

32
code/beginner/tutorial9-models/src/main.rs
Unescape Escape View File

@ -195,24 +195,24 @@ impl InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -268,7 +268,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -414,8 +414,10 @@ impl State {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -423,9 +425,13 @@ impl State {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: Some(wgpu::DepthStencilState {
format: texture::Texture::DEPTH_FORMAT,
@ -433,8 +439,6 @@ impl State {
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,
@ -498,8 +502,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -511,8 +515,8 @@ impl State {
store: true,
},
}],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_texture.view,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &self.depth_texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

6
code/beginner/tutorial9-models/src/model.rs
Unescape Escape View File

@ -27,17 +27,17 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

14
code/beginner/tutorial9-models/src/texture.rs
Unescape Escape View File

@ -1,6 +1,6 @@
use anyhow::*;
use image::GenericImageView;
use std::path::Path;
use std::{num::NonZeroU32, path::Path};
pub struct Texture {
pub texture: wgpu::Texture,
@ -32,7 +32,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
label: Some(label),
@ -88,7 +88,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -101,16 +101,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
&rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/intermediate/tutorial10-lighting/Cargo.toml
Unescape Escape View File

@ -8,12 +8,12 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
futures = "0.3"
image = "0.23"
log = "0.4"
tobj = "2.0"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

32
code/intermediate/tutorial10-lighting/src/main.rs
Unescape Escape View File

@ -203,24 +203,24 @@ impl model::Vertex for InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -285,8 +285,10 @@ fn create_render_pipeline(
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: color_format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
alpha: wgpu::BlendComponent::REPLACE,
color: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -294,9 +296,13 @@ fn create_render_pipeline(
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: depth_format.map(|format| wgpu::DepthStencilState {
format,
@ -304,8 +310,6 @@ fn create_render_pipeline(
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,
@ -344,7 +348,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -612,8 +616,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -625,8 +629,8 @@ impl State {
store: true,
},
}],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_texture.view,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &self.depth_texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

6
code/intermediate/tutorial10-lighting/src/model.rs
Unescape Escape View File

@ -27,17 +27,17 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

14
code/intermediate/tutorial10-lighting/src/texture.rs
Unescape Escape View File

@ -1,6 +1,6 @@
use anyhow::*;
use image::GenericImageView;
use std::path::Path;
use std::{num::NonZeroU32, path::Path};
pub struct Texture {
pub texture: wgpu::Texture,
@ -32,7 +32,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
label: Some(label),
@ -88,7 +88,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -101,16 +101,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
&rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/intermediate/tutorial11-normals/Cargo.toml
Unescape Escape View File

@ -8,12 +8,12 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
futures = "0.3"
image = "0.23"
log = "0.4"
tobj = "2.0"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

30
code/intermediate/tutorial11-normals/src/main.rs
Unescape Escape View File

@ -198,24 +198,24 @@ impl model::Vertex for InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -282,8 +282,10 @@ fn create_render_pipeline(
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: color_format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
alpha: wgpu::BlendComponent::REPLACE,
color: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -291,9 +293,11 @@ fn create_render_pipeline(
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
clamp_depth: false,
conservative: false,
},
depth_stencil: depth_format.map(|format| wgpu::DepthStencilState {
format,
@ -301,8 +305,6 @@ fn create_render_pipeline(
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,
@ -341,7 +343,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -661,8 +663,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -674,8 +676,8 @@ impl State {
store: true,
},
}],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_texture.view,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &self.depth_texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

10
code/intermediate/tutorial11-normals/src/model.rs
Unescape Escape View File

@ -29,28 +29,28 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
// Tangent and bitangent
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 3,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 11]>() as wgpu::BufferAddress,
shader_location: 4,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

14
code/intermediate/tutorial11-normals/src/texture.rs
Unescape Escape View File

@ -1,6 +1,6 @@
use anyhow::*;
use image::GenericImageView;
use std::path::Path;
use std::{num::NonZeroU32, path::Path};
pub struct Texture {
pub texture: wgpu::Texture,
@ -33,7 +33,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
label: Some(label),
@ -91,7 +91,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -108,16 +108,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
&rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/intermediate/tutorial12-camera/Cargo.toml
Unescape Escape View File

@ -8,12 +8,12 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
futures = "0.3"
image = "0.23"
log = "0.4"
tobj = "2.0"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

32
code/intermediate/tutorial12-camera/src/main.rs
Unescape Escape View File

@ -75,24 +75,24 @@ impl model::Vertex for InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -162,8 +162,10 @@ fn create_render_pipeline(
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: color_format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
alpha: wgpu::BlendComponent::REPLACE,
color: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -171,9 +173,13 @@ fn create_render_pipeline(
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: depth_format.map(|format| wgpu::DepthStencilState {
format,
@ -181,8 +187,6 @@ fn create_render_pipeline(
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,
@ -221,7 +225,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -568,8 +572,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -581,8 +585,8 @@ impl State {
store: true,
},
}],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_texture.view,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &self.depth_texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

10
code/intermediate/tutorial12-camera/src/model.rs
Unescape Escape View File

@ -29,28 +29,28 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
// Tangent and bitangent
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 3,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 11]>() as wgpu::BufferAddress,
shader_location: 4,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

14
code/intermediate/tutorial12-camera/src/texture.rs
Unescape Escape View File

@ -1,6 +1,6 @@
use anyhow::*;
use image::GenericImageView;
use std::path::Path;
use std::{num::NonZeroU32, path::Path};
pub struct Texture {
pub texture: wgpu::Texture,
@ -33,7 +33,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
label: Some(label),
@ -91,7 +91,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -108,16 +108,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
&rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/intermediate/tutorial13-threading/Cargo.toml
Unescape Escape View File

@ -8,13 +8,13 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
futures = "0.3"
image = "0.23"
log = "0.4"
rayon = "1.4" # NEW!
tobj = "2.0"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
[build-dependencies]

32
code/intermediate/tutorial13-threading/src/main.rs
Unescape Escape View File

@ -75,24 +75,24 @@ impl model::Vertex for InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -161,8 +161,10 @@ fn create_render_pipeline(
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: color_format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
alpha: wgpu::BlendComponent::REPLACE,
color: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -170,9 +172,13 @@ fn create_render_pipeline(
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: depth_format.map(|format| wgpu::DepthStencilState {
format,
@ -180,8 +186,6 @@ fn create_render_pipeline(
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,
@ -220,7 +224,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -563,8 +567,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -576,8 +580,8 @@ impl State {
store: true,
},
}],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_texture.view,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &self.depth_texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

10
code/intermediate/tutorial13-threading/src/model.rs
Unescape Escape View File

@ -30,28 +30,28 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
// Tangent and bitangent
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 3,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 11]>() as wgpu::BufferAddress,
shader_location: 4,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

14
code/intermediate/tutorial13-threading/src/texture.rs
Unescape Escape View File

@ -1,6 +1,6 @@
use anyhow::*;
use image::GenericImageView;
use std::path::Path;
use std::{num::NonZeroU32, path::Path};
pub struct Texture {
pub texture: wgpu::Texture,
@ -33,7 +33,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
label: Some(label),
@ -91,7 +91,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -108,16 +108,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
&rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

4
code/showcase/compute/Cargo.toml
Unescape Escape View File

@ -8,13 +8,13 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = ["derive"]}
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
futures = "0.3"
image = "0.23"
log = "0.4"
rayon = "1.4"
tobj = "2.0"
wgpu = { version = "0.7", features = ["trace"] }
wgpu = { version = "0.8", features = ["trace"] }
winit = "0.24"
[build-dependencies]

18
code/showcase/compute/src/main.rs
Unescape Escape View File

@ -78,24 +78,24 @@ impl model::Vertex for InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We don't have to do this in code though.
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}
@ -170,7 +170,7 @@ impl State {
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -529,8 +529,8 @@ impl State {
{
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -543,8 +543,8 @@ impl State {
},
}],
depth_stencil_attachment: Some(
wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_texture.view,
wgpu::RenderPassDepthStencilAttachment {
view: &self.depth_texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

12
code/showcase/compute/src/model.rs
Unescape Escape View File

@ -31,32 +31,32 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
// format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float2,
// format: wgpu::VertexFormat::Float32x3,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
// offset: mem::size_of::<[f32; 6]>() as wgpu::BufferAddress,
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
// Tangent and bitangent
wgpu::VertexAttribute {
// offset: mem::size_of::<[f32; 9]>() as wgpu::BufferAddress,
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 3,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
// offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
offset: mem::size_of::<[f32; 11]>() as wgpu::BufferAddress,
shader_location: 4,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

9
code/showcase/compute/src/pipeline.rs
Unescape Escape View File

@ -59,8 +59,7 @@ pub fn create_render_pipeline(
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: color_format,
color_blend: wgpu::BlendState::REPLACE,
alpha_blend: wgpu::BlendState::REPLACE,
blend: None,
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -68,9 +67,11 @@ pub fn create_render_pipeline(
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
clamp_depth: false,
conservative: false,
},
depth_stencil: depth_format.map(|format| wgpu::DepthStencilState {
format,
@ -78,8 +79,6 @@ pub fn create_render_pipeline(
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,

14
code/showcase/compute/src/texture.rs
Unescape Escape View File

@ -1,6 +1,6 @@
use anyhow::*;
use image::GenericImageView;
use std::path::Path;
use std::{num::NonZeroU32, path::Path};
pub struct Texture {
pub texture: wgpu::Texture,
@ -33,7 +33,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
label: Some(label),
@ -91,7 +91,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label,
@ -108,16 +108,16 @@ impl Texture {
});
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
&rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

2
code/showcase/framework/Cargo.toml
Unescape Escape View File

@ -14,7 +14,7 @@ futures = "0.3"
image = "0.23"
log = "0.4"
tobj = "2.0"
wgpu = "0.7"
wgpu = "0.8"
wgpu-subscriber = "0.1"
winit = "0.24"

2
code/showcase/framework/src/lib.rs
Unescape Escape View File

@ -57,7 +57,7 @@ impl Display {
.unwrap();
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,

10
code/showcase/framework/src/model.rs
Unescape Escape View File

@ -29,28 +29,28 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
// Tangent and bitangent
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 3,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 11]>() as wgpu::BufferAddress,
shader_location: 4,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

12
code/showcase/framework/src/pipeline.rs
Unescape Escape View File

@ -6,7 +6,7 @@ pub struct RenderPipelineBuilder<'a> {
vertex_shader: Option<wgpu::ShaderModuleDescriptor<'a>>,
fragment_shader: Option<wgpu::ShaderModuleDescriptor<'a>>,
front_face: wgpu::FrontFace,
cull_mode: wgpu::CullMode,
cull_mode: Option<wgpu::Face>,
depth_bias: i32,
depth_bias_slope_scale: f32,
depth_bias_clamp: f32,
@ -27,7 +27,7 @@ impl<'a> RenderPipelineBuilder<'a> {
vertex_shader: None,
fragment_shader: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::None,
cull_mode: None,
depth_bias: 0,
depth_bias_slope_scale: 0.0,
depth_bias_clamp: 0.0,
@ -64,7 +64,7 @@ impl<'a> RenderPipelineBuilder<'a> {
}
#[allow(dead_code)]
pub fn cull_mode(&mut self, cm: wgpu::CullMode) -> &mut Self {
pub fn cull_mode(&mut self, cm: Option<wgpu::Face>) -> &mut Self {
self.cull_mode = cm;
self
}
@ -102,8 +102,7 @@ impl<'a> RenderPipelineBuilder<'a> {
pub fn color_solid(&mut self, format: wgpu::TextureFormat) -> &mut Self {
self.color_state(wgpu::ColorTargetState {
format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: None,
write_mask: wgpu::ColorWrite::ALL,
})
}
@ -125,8 +124,6 @@ impl<'a> RenderPipelineBuilder<'a> {
depth_write_enabled,
depth_compare,
stencil: Default::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
bias: wgpu::DepthBiasState::default(),
})
}
@ -224,6 +221,7 @@ impl<'a> RenderPipelineBuilder<'a> {
cull_mode: self.cull_mode,
strip_index_format: None,
polygon_mode: wgpu::PolygonMode::Fill,
..Default::default()
},
depth_stencil: self.depth_stencil.clone(),
multisample: wgpu::MultisampleState {

16
code/showcase/framework/src/shader_canvas.rs
Unescape Escape View File

@ -80,8 +80,8 @@ impl ShaderCanvas {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Shader Canvas Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: frame,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Load,
@ -215,8 +215,10 @@ impl<'a> ShaderCanvasBuilder<'a> {
module: &frag_module,
targets: &[wgpu::ColorTargetState {
format: display_format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -224,9 +226,13 @@ impl<'a> ShaderCanvasBuilder<'a> {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {

16
code/showcase/framework/src/texture.rs
Unescape Escape View File

@ -1,6 +1,6 @@
use anyhow::*;
use image::GenericImageView;
use std::mem;
use std::{mem, num::NonZeroU32};
use std::path::Path;
use crate::buffer;
@ -76,7 +76,7 @@ impl<'a> Texture<'a> {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
size,
@ -94,16 +94,16 @@ impl<'a> Texture<'a> {
let texture = device.create_texture(&desc);
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
&rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);
@ -139,7 +139,7 @@ impl<'a> Texture<'a> {
size: wgpu::Extent3d {
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
@ -151,7 +151,7 @@ impl<'a> Texture<'a> {
}
pub fn prepare_buffer_rgba(&self, device: &wgpu::Device) -> buffer::RawBuffer<[f32; 4]> {
let num_pixels = self.desc.size.width * self.desc.size.height * self.desc.size.depth;
let num_pixels = self.desc.size.width * self.desc.size.height * self.desc.size.depth_or_array_layers;
let buffer_size = num_pixels * mem::size_of::<[f32; 4]>() as u32;
let buffer_usage = wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::MAP_READ;

4
code/showcase/gifs/Cargo.toml
Unescape Escape View File

@ -9,12 +9,12 @@ edition = "2018"
anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
futures = "0.3"
image = "0.23"
log = "0.4"
tobj = "2.0"
wgpu = "0.7"
wgpu = "0.8"
winit = "0.24"
gif = "0.10.3"

27
code/showcase/gifs/src/main.rs
Unescape Escape View File

@ -1,7 +1,7 @@
extern crate framework;
use anyhow::*;
use std::{iter, mem};
use std::{iter, mem, num::NonZeroU32};
async fn run() {
let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
@ -38,7 +38,7 @@ async fn run() {
size: wgpu::Extent3d {
width: texture_size,
height: texture_size,
depth: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
@ -80,8 +80,8 @@ async fn run() {
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("GIF Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &render_target.view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &render_target.view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -102,17 +102,17 @@ async fn run() {
drop(rpass);
encoder.copy_texture_to_buffer(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &render_target.texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
wgpu::BufferCopyView {
wgpu::ImageCopyBuffer {
buffer: &output_buffer,
layout: wgpu::TextureDataLayout {
layout: wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: padded_bytes_per_row,
rows_per_image: texture_size,
bytes_per_row: NonZeroU32::new(padded_bytes_per_row),
rows_per_image: NonZeroU32::new(texture_size),
},
},
render_target.desc.size,
@ -190,8 +190,7 @@ fn create_render_pipeline(
targets: &[
wgpu::ColorTargetState {
format: target.desc.format,
color_blend: wgpu::BlendState::REPLACE,
alpha_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState::REPLACE),
write_mask: wgpu::ColorWrite::ALL,
}
]
@ -200,9 +199,13 @@ fn create_render_pipeline(
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {

2
code/showcase/imgui-demo/Cargo.toml
Unescape Escape View File

@ -8,7 +8,7 @@ edition = "2018"
[dependencies]
anyhow = "1.0"
wgpu = "0.7"
wgpu = "0.8"
futures = "0.3"
imgui = "0.7"
imgui-wgpu = "0.14"

3
code/showcase/imgui-demo/src/main.rs
Unescape Escape View File

@ -115,7 +115,8 @@ impl framework::Demo for ImguiDemo {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("UI RenderPass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
attachment: &output.view,
resolve_target: None,
ops: wgpu::Operations {

2
code/showcase/pong/Cargo.toml
Unescape Escape View File

@ -11,7 +11,7 @@ anyhow = "1.0"
bytemuck = { version = "1.4", features = [ "derive" ] }
cgmath = "0.18"
futures = "0.3"
wgpu = "0.7"
wgpu = "0.8"
wgpu_glyph = "0.11"
rand = "0.8"
rodio = "0.13"

14
code/showcase/pong/src/render/mod.rs
Unescape Escape View File

@ -65,7 +65,7 @@ impl Render {
let size = video_mode.size();
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
@ -143,7 +143,8 @@ impl Render {
Ok(frame) => {
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Main Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
attachment: &frame.output.view,
resolve_target: None,
ops: wgpu::Operations::default(),
@ -258,14 +259,7 @@ fn create_render_pipeline(
write_mask: wgpu::ColorWrite::ALL,
}],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
},
RenderPassDepthStencilAttachment
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: 1,

2
code/showcase/windowless/Cargo.toml
Unescape Escape View File

@ -12,7 +12,7 @@ raw-window-handle = "0.3"
winit = "0.24"
shaderc = "0.7"
cgmath = "0.18"
wgpu = "0.7"
wgpu = "0.8"
futures = "0.3.4"
[[bin]]

30
code/showcase/windowless/src/main.rs
Unescape Escape View File

@ -1,3 +1,5 @@
use std::num::NonZeroU32;
async fn run() {
let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
let adapter = instance
@ -17,7 +19,7 @@ async fn run() {
size: wgpu::Extent3d {
width: texture_size,
height: texture_size,
depth: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
@ -96,8 +98,10 @@ async fn run() {
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: texture_desc.format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
alpha: wgpu::BlendComponent::REPLACE,
color: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
@ -105,9 +109,13 @@ async fn run() {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
// Requires Features::DEPTH_CLAMPING
clamp_depth: false,
// Requires Features::CONSERVATIVE_RASTERIZATION
conservative: false,
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
@ -123,8 +131,8 @@ async fn run() {
{
let render_pass_desc = wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &texture_view,
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &texture_view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
@ -145,17 +153,17 @@ async fn run() {
}
encoder.copy_texture_to_buffer(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
wgpu::BufferCopyView {
wgpu::ImageCopyBuffer {
buffer: &output_buffer,
layout: wgpu::TextureDataLayout {
layout: wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: u32_size * texture_size,
rows_per_image: texture_size,
bytes_per_row: NonZeroU32::new(u32_size * texture_size),
rows_per_image: NonZeroU32::new(texture_size),
},
},
texture_desc.size,

4
docs/beginner/tutorial1-window/README.md
Unescape Escape View File

@ -12,9 +12,9 @@ image = "0.23"
winit = "0.24"
shaderc = "0.7"
cgmath = "0.18"
env_logger = "0.7"
env_logger = "0.8"
log = "0.4"
wgpu = "0.7"
wgpu = "0.8"
futures = "0.3"
```

2
docs/beginner/tutorial2-swapchain/README.md
Unescape Escape View File

@ -95,7 +95,7 @@ The `limits` field describes the limit of certain types of resource we can creat
```rust
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface),
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,

4
docs/beginner/tutorial3-pipeline/README.md
Unescape Escape View File

@ -170,7 +170,7 @@ Two things to note here:
topology: wgpu::PrimitiveTopology::TriangleList, // 1.
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw, // 2.
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
},
@ -279,7 +279,7 @@ image = "0.23"
winit = "0.24"
# shaderc = "0.7" # REMOVED!
cgmath = "0.18"
wgpu = "0.7"
wgpu = "0.8"
futures = "0.3"
# NEW!

8
docs/beginner/tutorial4-buffer/README.md
Unescape Escape View File

@ -126,12 +126,12 @@ wgpu::VertexBufferLayout {
wgpu::VertexAttribute {
offset: 0, // 4.
shader_location: 0, // 5.
format: wgpu::VertexFormat::Float3, // 6.
format: wgpu::VertexFormat::Float32x3, // 6.
},
wgpu::VertexAttribute {
offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
}
]
}
@ -161,12 +161,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
}
]
}

26
docs/beginner/tutorial5-textures/README.md
Unescape Escape View File

@ -34,7 +34,7 @@ Now, let's create the `Texture`:
let texture_size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let diffuse_texture = device.create_texture(
&wgpu::TextureDescriptor {
@ -60,7 +60,7 @@ The `Texture` struct has no methods to interact with the data directly. However,
```rust
queue.write_texture(
// Tells wgpu where to copy the pixel data
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &diffuse_texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
@ -68,7 +68,7 @@ queue.write_texture(
// The actual pixel data
diffuse_rgba,
// The layout of the texture
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
@ -95,13 +95,13 @@ let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor
});
encoder.copy_buffer_to_texture(
wgpu::BufferCopyView {
wgpu::ImageCopyBuffer {
buffer: &buffer,
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
},
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &diffuse_texture,
mip_level: 0,
array_layer: 0,
@ -318,12 +318,12 @@ impl Vertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2, // NEW!
format: wgpu::VertexFormat::Float32x2, // NEW!
},
]
}
@ -426,7 +426,7 @@ For convenience sake, let's pull our texture code into its module. We'll first n
image = "0.23"
cgmath = "0.18"
winit = "0.24"
env_logger = "0.7"
env_logger = "0.8"
log = "0.4"
futures = "0.3"
wgpu ="0.6"
@ -469,7 +469,7 @@ impl Texture {
let size = wgpu::Extent3d {
width: dimensions.0,
height: dimensions.1,
depth: 1,
depth_or_array_layers: 1,
};
let texture = device.create_texture(
&wgpu::TextureDescriptor {
@ -484,16 +484,16 @@ impl Texture {
);
queue.write_texture(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
rgba,
wgpu::TextureDataLayout {
wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: 4 * dimensions.0,
rows_per_image: dimensions.1,
bytes_per_row: NonZeroU32::new(4 * dimensions.0),
rows_per_image: NonZeroU32::new(dimensions.1),
},
size,
);

8
docs/beginner/tutorial7-instancing/README.md
Unescape Escape View File

@ -146,7 +146,7 @@ impl InstanceRaw {
// While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll
// be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later
shader_location: 5,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
// A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot
// for each vec4. We'll have to reassemble the mat4 in
@ -154,17 +154,17 @@ impl InstanceRaw {
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress,
shader_location: 6,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 7,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress,
shader_location: 8,
format: wgpu::VertexFormat::Float4,
format: wgpu::VertexFormat::Float32x4,
},
],
}

4
docs/beginner/tutorial8-depth/README.md
Unescape Escape View File

@ -30,7 +30,7 @@ impl Texture {
let size = wgpu::Extent3d { // 2.
width: sc_desc.width,
height: sc_desc.height,
depth: 1,
depth_or_array_layers: 1,
};
let desc = wgpu::TextureDescriptor {
label: Some(label),
@ -145,7 +145,7 @@ The last change we need to make is in the `render()` function. We've created the
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
// ...
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachmentDescriptor {
attachment: &self.depth_texture.view,
view: &self.depth_texture.view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: true,

6
docs/beginner/tutorial9-models/README.md
Unescape Escape View File

@ -42,17 +42,17 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: 0,
shader_location: 0,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
shader_location: 1,
format: wgpu::VertexFormat::Float2,
format: wgpu::VertexFormat::Float32x2,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
shader_location: 2,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

17
docs/intermediate/tutorial10-lighting/README.md
Unescape Escape View File

@ -135,27 +135,20 @@ fn create_render_pipeline(
entry_point: "main",
targets: &[wgpu::ColorTargetState {
format: color_format,
alpha_blend: wgpu::BlendState::REPLACE,
color_blend: wgpu::BlendState::REPLACE,
blend: Some(wgpu::BlendState {
alpha: wgpu::BlendComponent::REPLACE,
color: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
}],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
},
RenderPassDepthStencilAttachment
depth_stencil: depth_format.map(|format| wgpu::DepthStencilState {
format,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
// Setting this to true requires Features::DEPTH_CLAMPING
clamp_depth: false,
}),
multisample: wgpu::MultisampleState {
count: 1,

4
docs/intermediate/tutorial11-normals/README.md
Unescape Escape View File

@ -186,12 +186,12 @@ impl Vertex for ModelVertex {
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress,
shader_location: 3,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
wgpu::VertexAttribute {
offset: mem::size_of::<[f32; 11]>() as wgpu::BufferAddress,
shader_location: 4,
format: wgpu::VertexFormat::Float3,
format: wgpu::VertexFormat::Float32x3,
},
],
}

14
docs/news/README.md
Unescape Escape View File

@ -1,5 +1,19 @@
# News
## 0.8
* The `depth` field is now `depth_or_array_layers`
* `wgpu::VertexFormat::Float3` is now `wgpu::VertexFormat::Float32x3`. Similar things apply to `Float2` and `Float4`
* `CullMode` is no longer a thing, instead `PrimitiveState::cull_mode` will require an `Option<Face>`
* Added `clamp_depth` and `conservative` to `PrimitiveState`. Part of this means that `DepthStencilState` no longer has a `clamp_depth` field.
* `color_blend` and `alpha_blend` have been moved into the new `blend` field with accepts an `Option<wgpu::BlendState>`
* `adapter.get_swap_chain_preferred_format()` now returns an `Option<wgpu::TextureFormat>`
* `wgpu::RenderPassColorAttachmentDescriptor` has been renamed `wgpu::RenderPassColorAttachement` and the `attachment` field has been renamed to `view`
* `wgpu::RenderPassDepthStencialAttachmentDescriptor` also loses the `Descriptor` part of it's name. `attachment` gets renamed to `view` as well.
* `wgpu::TextureCopyView` has been renamed to `wgpu::ImageCopyTexture`. This is a typedef for `wgpu::ImageCopyTextureBase<T>`
* `wgpu::TextureDataLayout` is now `wgpu::ImageDataLayout` and it's `bytes_per_row` and `rows_per_image` now take `NonZeroU32`.
* `wgpu::ImageCopyBuffer` is now `wgpu::ImageCopyBuffer`.
## 0.7
There were a lot of changes particularly to the `RenderPipelineDescriptor`. Most other things have not changed. You can check out the [0.9 PR](https://github.com/sotrh/learn-wgpu/pull/140) for the full details.

8
docs/showcase/gifs/README.md
Unescape Escape View File

@ -54,7 +54,7 @@ let rt_desc = wgpu::TextureDescriptor {
size: wgpu::Extent3d {
width: texture_size,
height: texture_size,
depth: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
@ -125,14 +125,14 @@ for c in &colors {
drop(rpass);
encoder.copy_texture_to_buffer(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &render_target.texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
wgpu::BufferCopyView {
wgpu::ImageCopyBuffer {
buffer: &output_buffer,
layout: wgpu::TextureDataLayout {
layout: wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: padded_bytes_per_row,
rows_per_image: texture_size,

3
docs/showcase/imgui-demo/README.md
Unescape Escape View File

@ -111,7 +111,8 @@ if self.last_cursor != ui.mouse_cursor() {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("UI RenderPass"),
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
color_attachments: &[wgpu::RenderPassColorAttachment {
view: &frame.view,
attachment: &output.view,
resolve_target: None,
ops: wgpu::Operations {

10
docs/showcase/windowless/README.md
Unescape Escape View File

@ -31,7 +31,7 @@ let texture_desc = wgpu::TextureDescriptor {
size: wgpu::Extent3d {
width: texture_size,
height: texture_size,
depth: 1,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
@ -159,7 +159,7 @@ let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescrip
topology: wgpu::PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw,
cull_mode: wgpu::CullMode::Back,
cull_mode: Some(wgpu::Face::Back),
// Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE
polygon_mode: wgpu::PolygonMode::Fill,
},
@ -214,14 +214,14 @@ There's not much we can do with the data when it's stuck in a `Texture`, so let'
```rust
encoder.copy_texture_to_buffer(
wgpu::TextureCopyView {
wgpu::ImageCopyTexture {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
},
wgpu::BufferCopyView {
wgpu::ImageCopyBuffer {
buffer: &output_buffer,
layout: wgpu::TextureDataLayout {
layout: wgpu::ImageDataLayout {
offset: 0,
bytes_per_row: u32_size * texture_size,
rows_per_image: texture_size,

Write Preview
Loading…
Cancel
Save