Merge pull request #448 from sotrh/0.15

0.15
pull/449/head
sotrh 1 year ago committed by GitHub
commit 04276c1500
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

728
Cargo.lock generated

File diff suppressed because it is too large Load Diff

@ -14,5 +14,5 @@ members = [
] ]
exclude = [ exclude = [
"code/showcase/imgui-demo", "code/showcase/imgui-demo",
#"code/showcase/pong", "code/showcase/pong",
] ]

@ -16,13 +16,13 @@ cfg-if = "1"
winit = "0.27" winit = "0.27"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
wgpu = "0.14" wgpu = "0.15"
pollster = "0.2" pollster = "0.2"
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1.6" console_error_panic_hook = "0.1.6"
console_log = "0.2.0" console_log = "0.2.0"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2.76" wasm-bindgen = "0.2.76"
wasm-bindgen-futures = "0.4.30" wasm-bindgen-futures = "0.4.30"
web-sys = { version = "0.3.53", features = [ web-sys = { version = "0.3.53", features = [

@ -12,13 +12,13 @@ cfg-if = "1"
winit = "0.27" winit = "0.27"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
wgpu = "0.14" wgpu = "0.15"
pollster = "0.2" pollster = "0.2"
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1.6" console_error_panic_hook = "0.1.6"
console_log = "0.2.0" console_log = "0.2.0"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -26,13 +26,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -61,13 +64,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -24,14 +24,17 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(), power_preference: wgpu::PowerPreference::default(),
@ -60,13 +63,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -12,13 +12,13 @@ cfg-if = "1"
winit = "0.27" winit = "0.27"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
wgpu = "0.14" wgpu = "0.15"
pollster = "0.2" pollster = "0.2"
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1.6" console_error_panic_hook = "0.1.6"
console_log = "0.2.0" console_log = "0.2.0"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -24,13 +24,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -59,13 +62,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -26,13 +26,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -61,13 +64,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -11,7 +11,7 @@ crate-type = ["cdylib", "rlib"]
[dependencies] [dependencies]
cfg-if = "1" cfg-if = "1"
winit = "0.27" winit = "0.27"
wgpu = "0.14" wgpu = "0.15"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
pollster = "0.2" pollster = "0.2"
@ -21,7 +21,7 @@ bytemuck = { version = "1.12", features = [ "derive" ] }
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -87,13 +87,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -122,13 +125,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -83,13 +83,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -118,13 +121,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -14,7 +14,7 @@ bytemuck = { version = "1.12", features = [ "derive" ] }
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
pollster = "0.2" pollster = "0.2"
wgpu = "0.14" wgpu = "0.15"
winit = "0.27" winit = "0.27"
[dependencies.image] [dependencies.image]
@ -25,7 +25,7 @@ features = ["png", "jpeg"]
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -89,13 +89,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -123,13 +126,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -89,13 +89,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -123,13 +126,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -34,14 +34,16 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = wgpu::TextureFormat::Rgba8UnormSrgb;
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb, format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -15,7 +15,7 @@ cgmath = "0.18"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
pollster = "0.2" pollster = "0.2"
wgpu = "0.14" wgpu = "0.15"
winit = "0.27" winit = "0.27"
[dependencies.image] [dependencies.image]
@ -26,7 +26,7 @@ features = ["png", "jpeg"]
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -239,13 +239,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -273,13 +276,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -239,13 +239,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -273,13 +276,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -34,14 +34,16 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = wgpu::TextureFormat::Rgba8UnormSrgb;
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb, format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -15,7 +15,7 @@ cgmath = "0.18"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
pollster = "0.2" pollster = "0.2"
wgpu = "0.14" wgpu = "0.15"
winit = "0.27" winit = "0.27"
[dependencies.image] [dependencies.image]
@ -26,7 +26,7 @@ features = ["png", "jpeg"]
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -293,13 +293,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -327,13 +330,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -300,13 +300,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -334,13 +337,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -34,14 +34,16 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = wgpu::TextureFormat::Rgba8UnormSrgb;
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb, format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -15,7 +15,7 @@ cgmath = "0.18"
env_logger = "0.10" env_logger = "0.10"
pollster = "0.2" pollster = "0.2"
log = "0.4" log = "0.4"
wgpu = "0.14" wgpu = "0.15"
winit = "0.27" winit = "0.27"
[dependencies.image] [dependencies.image]
@ -26,7 +26,7 @@ features = ["png", "jpeg"]
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -482,13 +482,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -516,13 +519,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -310,13 +310,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -344,13 +347,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -30,6 +30,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -71,6 +72,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -118,14 +120,16 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = wgpu::TextureFormat::Rgba8UnormSrgb;
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb, format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -16,7 +16,7 @@ env_logger = "0.10"
pollster = "0.2" pollster = "0.2"
log = "0.4" log = "0.4"
tobj = { version = "3.2", features = ["async"]} tobj = { version = "3.2", features = ["async"]}
wgpu = "0.14" wgpu = "0.15"
winit = "0.27" winit = "0.27"
[dependencies.image] [dependencies.image]
@ -28,7 +28,7 @@ features = ["png", "jpeg"]
reqwest = { version = "0.11" } reqwest = { version = "0.11" }
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -250,13 +250,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
log::warn!("WGPU setup"); log::warn!("WGPU setup");
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -287,13 +290,23 @@ impl State {
.unwrap(); .unwrap();
log::warn!("Surface"); log::warn!("Surface");
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -29,6 +29,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -77,14 +78,16 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = wgpu::TextureFormat::Rgba8UnormSrgb;
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb, format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -16,7 +16,7 @@ env_logger = "0.10"
pollster = "0.2" pollster = "0.2"
log = "0.4" log = "0.4"
tobj = { version = "3.2", features = ["async"]} tobj = { version = "3.2", features = ["async"]}
wgpu = { version = "0.14"} wgpu = { version = "0.15"}
winit = "0.27" winit = "0.27"
[dependencies.image] [dependencies.image]
@ -28,7 +28,7 @@ features = ["png", "jpeg"]
reqwest = { version = "0.11" } reqwest = { version = "0.11" }
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -345,13 +345,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -379,13 +382,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -29,6 +29,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -77,14 +78,16 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = wgpu::TextureFormat::Rgba8UnormSrgb;
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb, format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -16,7 +16,7 @@ env_logger = "0.10"
pollster = "0.2" pollster = "0.2"
log = "0.4" log = "0.4"
tobj = { version = "3.2", features = ["async"]} tobj = { version = "3.2", features = ["async"]}
wgpu = { version = "0.14"} wgpu = { version = "0.15"}
winit = "0.27" winit = "0.27"
[dependencies.image] [dependencies.image]
@ -28,7 +28,7 @@ features = ["png", "jpeg"]
reqwest = { version = "0.11" } reqwest = { version = "0.11" }
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -345,13 +345,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -379,13 +382,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -29,6 +29,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -78,18 +79,20 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = if is_normal_map {
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
};
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: if is_normal_map { format,
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
},
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -16,7 +16,7 @@ env_logger = "0.10"
pollster = "0.2" pollster = "0.2"
log = "0.4" log = "0.4"
tobj = { version = "3.2", features = ["async"]} tobj = { version = "3.2", features = ["async"]}
wgpu = { version = "0.14"} wgpu = { version = "0.15"}
winit = "0.27" winit = "0.27"
instant = "0.1" instant = "0.1"
@ -29,7 +29,7 @@ features = ["png", "jpeg"]
reqwest = { version = "0.11" } reqwest = { version = "0.11" }
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -225,13 +225,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -259,13 +262,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -29,6 +29,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -79,18 +80,20 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = if is_normal_map {
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
};
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: if is_normal_map { format,
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
},
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -16,7 +16,7 @@ env_logger = "0.10"
pollster = "0.2" pollster = "0.2"
log = "0.4" log = "0.4"
tobj = { version = "3.2", features = ["async"]} tobj = { version = "3.2", features = ["async"]}
wgpu = { version = "0.14"} wgpu = { version = "0.15"}
winit = "0.27" winit = "0.27"
instant = "0.1" instant = "0.1"
@ -29,7 +29,7 @@ features = ["png", "jpeg"]
reqwest = { version = "0.11" } reqwest = { version = "0.11" }
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -227,13 +227,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -261,13 +264,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);
@ -527,10 +540,10 @@ impl State {
); );
let mut terrain = terrain::Terrain::new(chunk_size, min_max_height); let mut terrain = terrain::Terrain::new(chunk_size, min_max_height);
terrain.gen_chunk(&device, &queue, &terrain_hack_pipeline, cgmath::Vector3::zero()); terrain.gen_chunk(&device, &queue, &terrain_pipeline, cgmath::Vector3::zero());
// terrain.gen_chunk(&device, &queue, &terrain_hack_pipeline, (0.0, 0.0, -(chunk_size.y as f32)).into()); terrain.gen_chunk(&device, &queue, &terrain_pipeline, (0.0, 0.0, -(chunk_size.y as f32)).into());
// terrain.gen_chunk(&device, &queue, &terrain_hack_pipeline, (-(chunk_size.x as f32), 0.0, -(chunk_size.y as f32)).into()); terrain.gen_chunk(&device, &queue, &terrain_pipeline, (-(chunk_size.x as f32), 0.0, -(chunk_size.y as f32)).into());
// terrain.gen_chunk(&device, &queue, &terrain_hack_pipeline, (-(chunk_size.x as f32), 0.0, 0.0).into()); terrain.gen_chunk(&device, &queue, &terrain_pipeline, (-(chunk_size.x as f32), 0.0, 0.0).into());
Self { Self {
window, window,
@ -687,7 +700,7 @@ impl State {
// &self.light_bind_group, // &self.light_bind_group,
// ); // );
self.terrain_hack_pipeline.render(&mut render_pass, &self.terrain, &self.camera_bind_group, &self.light_bind_group); self.terrain_pipeline.render(&mut render_pass, &self.terrain, &self.camera_bind_group, &self.light_bind_group);
} }
self.queue.submit(iter::once(encoder.finish())); self.queue.submit(iter::once(encoder.finish()));
output.present(); output.present();

@ -205,7 +205,7 @@ impl GenerateChunk for TerrainPipeline {
size: (num_vertices * 8 * std::mem::size_of::<f32>() as u32) as _, size: (num_vertices * 8 * std::mem::size_of::<f32>() as u32) as _,
usage: wgpu::BufferUsages::STORAGE usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::VERTEX
| wgpu::BufferUsages::MAP_READ, | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false, mapped_at_creation: false,
}); });
let num_elements = self.chunk_size.x * self.chunk_size.y * 6; let num_elements = self.chunk_size.x * self.chunk_size.y * 6;
@ -215,7 +215,7 @@ impl GenerateChunk for TerrainPipeline {
size: (num_elements * std::mem::size_of::<u32>() as u32) as _, size: (num_elements * std::mem::size_of::<u32>() as u32) as _,
usage: wgpu::BufferUsages::STORAGE usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::INDEX | wgpu::BufferUsages::INDEX
| wgpu::BufferUsages::MAP_READ, | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false, mapped_at_creation: false,
}); });
Chunk { Chunk {
@ -446,6 +446,7 @@ impl TerrainHackPipeline {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::R32Uint, format: wgpu::TextureFormat::R32Uint,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
view_formats: &[wgpu::TextureFormat::R32Uint],
}) })
} }
} }

@ -218,8 +218,8 @@ fn gen_terrain_fragment(in: GenVertexOutput) -> GenFragmentOutput {
// indices.data[start_index + 4u] = v11; // indices.data[start_index + 4u] = v11;
// indices.data[start_index + 5u] = v10; // indices.data[start_index + 5u] = v10;
let vert_component = bitcast<u32>(vert_component); let ivert_component = bitcast<u32>(vert_component);
return GenFragmentOutput(vert_component, index); return GenFragmentOutput(ivert_component, index);
} }
// ============================ // ============================

@ -29,6 +29,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -79,18 +80,20 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = if is_normal_map {
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
};
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: if is_normal_map { format,
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
},
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -14,7 +14,7 @@ image = "0.24"
log = "0.4" log = "0.4"
rayon = "1.4" rayon = "1.4"
tobj = "2.0" tobj = "2.0"
wgpu = "0.14" wgpu = "0.15"
winit = "0.27" winit = "0.27"
[build-dependencies] [build-dependencies]

@ -164,13 +164,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -198,13 +201,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -43,6 +43,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -93,18 +94,20 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = if is_normal_map {
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
};
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: if is_normal_map { format,
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
},
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -14,7 +14,7 @@ pollster = "0.2"
image = "0.24.2" image = "0.24.2"
log = "0.4" log = "0.4"
tobj = "2.0" tobj = "2.0"
wgpu = "0.14" wgpu = "0.15"
wgpu-subscriber = "0.1" wgpu-subscriber = "0.1"
winit = "0.27" winit = "0.27"

@ -34,8 +34,11 @@ pub struct Display {
impl Display { impl Display {
pub async fn new(window: Window) -> Result<Self, Error> { pub async fn new(window: Window) -> Result<Self, Error> {
let size = window.inner_size(); let size = window.inner_size();
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
let surface = unsafe { instance.create_surface(&window) }; backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(), power_preference: wgpu::PowerPreference::default(),
@ -61,13 +64,23 @@ impl Display {
) )
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -78,18 +78,20 @@ impl<'a> Texture<'a> {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = if is_normal_map {
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
};
let desc = wgpu::TextureDescriptor { let desc = wgpu::TextureDescriptor {
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: if is_normal_map { format,
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
},
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
label: None, label: None,
view_formats: &[],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
@ -147,6 +149,7 @@ impl<'a> Texture<'a> {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[Self::DEPTH_FORMAT],
}; };
Self::from_descriptor(device, desc) Self::from_descriptor(device, desc)
} }

@ -14,7 +14,7 @@ pollster = "0.2"
image = "0.24.2" image = "0.24.2"
log = "0.4" log = "0.4"
tobj = "3.1" tobj = "3.1"
wgpu = "0.14" wgpu = "0.15"
winit = "0.27" winit = "0.27"
gif = "0.11.4" gif = "0.11.4"
futures-intrusive = "0.4" futures-intrusive = "0.4"

@ -4,7 +4,10 @@ extern crate framework;
use std::{iter, mem, num::NonZeroU32}; use std::{iter, mem, num::NonZeroU32};
async fn run() { async fn run() {
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions::default()) .request_adapter(&wgpu::RequestAdapterOptions::default())
.await .await
@ -52,6 +55,7 @@ async fn run() {
format: wgpu::TextureFormat::Rgba8UnormSrgb, format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::RENDER_ATTACHMENT,
label: None, label: None,
view_formats: &[],
}; };
let render_target = framework::Texture::from_descriptor(&device, rt_desc); let render_target = framework::Texture::from_descriptor(&device, rt_desc);

@ -8,7 +8,7 @@ edition = "2018"
[dependencies] [dependencies]
anyhow = "1.0" anyhow = "1.0"
wgpu = "0.14" wgpu = "0.15"
pollster = "0.2" pollster = "0.2"
imgui = "0.7" imgui = "0.7"
imgui-wgpu = "0.17" imgui-wgpu = "0.17"

@ -7,6 +7,6 @@ edition = "2021"
[dependencies] [dependencies]
anyhow = "1" anyhow = "1"
wgpu = "0.14" wgpu = "0.15"
winit = "0.27" winit = "0.27"
pollster = "0.2" pollster = "0.2"

@ -19,8 +19,8 @@ async fn run() -> anyhow::Result<()> {
.build(&event_loop)?; .build(&event_loop)?;
let backends = wgpu::Backends::all(); let backends = wgpu::Backends::all();
let instance = wgpu::Instance::new(backends); let instance = wgpu::Instance::default();
let surface = unsafe { instance.create_surface(window.as_ref().unwrap()) }; let surface = unsafe { instance.create_surface(window.as_ref().unwrap()) }.unwrap();
let adapter = instance let adapter = instance
.enumerate_adapters(backends) .enumerate_adapters(backends)
.filter(|a| a.is_surface_supported(&surface)) .filter(|a| a.is_surface_supported(&surface))
@ -41,10 +41,11 @@ async fn run() -> anyhow::Result<()> {
let mut config = wgpu::SurfaceConfiguration { let mut config = wgpu::SurfaceConfiguration {
width: inner_size.width, width: inner_size.width,
height: inner_size.height, height: inner_size.height,
format: surface.get_supported_formats(&adapter)[0], format: surface.get_capabilities(&adapter).formats[0],
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
present_mode: Default::default(), present_mode: Default::default(),
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: wgpu::CompositeAlphaMode::Auto,
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -16,7 +16,7 @@ env_logger = "0.10"
pollster = "0.2" pollster = "0.2"
log = "0.4" log = "0.4"
tobj = { version = "3.2", features = ["async"]} tobj = { version = "3.2", features = ["async"]}
wgpu = { version = "0.14"} wgpu = { version = "0.15"}
winit = "0.27" winit = "0.27"
instant = "0.1" instant = "0.1"
@ -29,7 +29,7 @@ features = ["png", "jpeg"]
reqwest = { version = "0.11" } reqwest = { version = "0.11" }
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -230,13 +230,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -264,13 +267,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -29,6 +29,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -79,18 +80,20 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = if is_normal_map {
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
};
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: if is_normal_map { format,
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
},
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -15,7 +15,7 @@ anyhow = "1.0"
bytemuck = { version = "1.12", features = [ "derive" ] } bytemuck = { version = "1.12", features = [ "derive" ] }
cgmath = "0.18" cgmath = "0.18"
pollster = "0.2" pollster = "0.2"
wgpu = { version = "0.14", features = ["spirv"]} wgpu = { version = "0.15", features = ["spirv"]}
wgpu_glyph = "0.18" wgpu_glyph = "0.18"
rand = "0.8" rand = "0.8"
rodio = { version = "0.16", default-features = false, features = ["wav"] } rodio = { version = "0.16", default-features = false, features = ["wav"] }
@ -34,11 +34,11 @@ web-sys = { version = "0.3.53", features = [
"Window", "Window",
"Element", "Element",
]} ]}
wgpu = { version = "0.14", features = ["spirv", "webgl"]} wgpu = { version = "0.15", features = ["spirv", "webgl"]}
[build-dependencies] [build-dependencies]
anyhow = "1.0" anyhow = "1.0"
fs_extra = "1.2" fs_extra = "1.2"
glob = "0.3" glob = "0.3"
rayon = "1.4" rayon = "1.4"
naga = { version = "0.10", features = ["glsl-in", "spv-out", "wgsl-out"]} naga = { version = "0.11", features = ["glsl-in", "spv-out", "wgsl-out"]}

@ -40,13 +40,16 @@ impl Render {
log::warn!("size: {:?}", size); log::warn!("size: {:?}", size);
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -68,13 +71,23 @@ impl Render {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -17,7 +17,7 @@ pollster = "0.2"
log = "0.4" log = "0.4"
rayon = "1.4" # NEW! rayon = "1.4" # NEW!
tobj = { version = "3.2", features = ["async"]} tobj = { version = "3.2", features = ["async"]}
wgpu = { version = "0.14"} wgpu = { version = "0.15"}
winit = "0.27" winit = "0.27"
instant = "0.1" instant = "0.1"
async-std = "1" async-std = "1"
@ -31,7 +31,7 @@ features = ["png", "jpeg"]
reqwest = { version = "0.11" } reqwest = { version = "0.11" }
console_error_panic_hook = "0.1" console_error_panic_hook = "0.1"
console_log = "0.2" console_log = "0.2"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -224,13 +224,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU // BackendBit::PRIMARY => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
@ -258,13 +261,23 @@ impl State {
.await .await
.unwrap(); .unwrap();
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);

@ -29,6 +29,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT, format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[Self::DEPTH_FORMAT],
}; };
let texture = device.create_texture(&desc); let texture = device.create_texture(&desc);
let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@ -79,18 +80,20 @@ impl Texture {
height: dimensions.1, height: dimensions.1,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let format = if is_normal_map {
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
};
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: if is_normal_map { format,
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
},
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
queue.write_texture( queue.write_texture(

@ -9,7 +9,7 @@ edition = "2018"
[dependencies] [dependencies]
image = "0.24" image = "0.24"
shaderc = "0.8" shaderc = "0.8"
wgpu = { version = "0.14", features = ["spirv"] } wgpu = { version = "0.15", features = ["spirv"] }
pollster = "0.2" pollster = "0.2"
futures-intrusive = "0.4" futures-intrusive = "0.4"

@ -1,7 +1,10 @@
use std::num::NonZeroU32; use std::num::NonZeroU32;
async fn run() { async fn run() {
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
let adapter = instance let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions { .request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(), power_preference: wgpu::PowerPreference::default(),
@ -28,6 +31,7 @@ async fn run() {
format: wgpu::TextureFormat::Rgba8UnormSrgb, format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::RENDER_ATTACHMENT,
label: None, label: None,
view_formats: &[],
}; };
let texture = device.create_texture(&texture_desc); let texture = device.create_texture(&texture_desc);
let texture_view = texture.create_view(&Default::default()); let texture_view = texture.create_view(&Default::default());

@ -25,17 +25,20 @@ I'm using this project to learn wgpu myself, so I might miss some important deta
## Special thanks to these patrons! ## Special thanks to these patrons!
- David Laban - David Laban
- Gunstein Vatnar
- Lennart - Lennart
- Ian Gowen - Ian Gowen
- Aron Granberg - Aron Granberg
- Bernard Llanos - Bernard Llanos
- Jan Šipr - Jan Šipr
- Zeh Fernando - Zeh Fernando
- Felix
- Youngsuk Kim - Youngsuk Kim
- オリトイツキ - オリトイツキ
- Andrea Postal - Andrea Postal
- charlesk - Julius Liu
- Feng Liang
- Mattia Samiolo
- Joris Willems
- Jani Turkia
- papyDoctor
- Filip

@ -11,7 +11,7 @@ For the beginner stuff, we're going to keep things very simple, we'll add things
winit = "0.27" winit = "0.27"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
wgpu = "0.14" wgpu = "0.15"
``` ```
## Using Rust's new resolver ## Using Rust's new resolver
@ -110,7 +110,7 @@ cfg-if = "1"
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1.6" console_error_panic_hook = "0.1.6"
console_log = "0.2.0" console_log = "0.2.0"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4.30" wasm-bindgen-futures = "0.4.30"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -57,13 +57,16 @@ impl State {
// The instance is a handle to our GPU // The instance is a handle to our GPU
// Backends::all => Vulkan + Metal + DX12 + Browser WebGPU // Backends::all => Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all()); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
backends: wgpu::Backends::all(),
dx12_shader_compiler: Default::default(),
});
// # Safety // # Safety
// //
// The surface needs to live as long as the window that created it. // The surface needs to live as long as the window that created it.
// State owns the window so this should be safe. // State owns the window so this should be safe.
let surface = unsafe { instance.create_surface(&window) }; let surface = unsafe { instance.create_surface(&window) }.unwrap();
let adapter = instance.request_adapter( let adapter = instance.request_adapter(
&wgpu::RequestAdapterOptions { &wgpu::RequestAdapterOptions {
@ -95,12 +98,14 @@ let adapter = instance
.enumerate_adapters(wgpu::Backends::all()) .enumerate_adapters(wgpu::Backends::all())
.filter(|adapter| { .filter(|adapter| {
// Check if this adapter supports our surface // Check if this adapter supports our surface
!surface.get_supported_formats(&adapter).is_empty() adapter.is_surface_supported(&surface)
}) })
.next() .next()
.unwrap() .unwrap()
``` ```
One thing to note is that `enumerate_adapters` isn't available on WASM, so you have to use `request_adapter`.
Another thing to note is that `Adapter`s are locked to a specific backend. If you are on Windows and have 2 graphics cards you'll have at least 4 adapters available to use, 2 Vulkan and 2 DirectX. Another thing to note is that `Adapter`s are locked to a specific backend. If you are on Windows and have 2 graphics cards you'll have at least 4 adapters available to use, 2 Vulkan and 2 DirectX.
For more fields you can use to refine your search, [check out the docs](https://docs.rs/wgpu/latest/wgpu/struct.Adapter.html). For more fields you can use to refine your search, [check out the docs](https://docs.rs/wgpu/latest/wgpu/struct.Adapter.html).
@ -148,13 +153,23 @@ You can view a full list of features [here](https://docs.rs/wgpu/latest/wgpu/str
The `limits` field describes the limit of certain types of resources that we can create. We'll use the defaults for this tutorial, so we can support most devices. You can view a list of limits [here](https://docs.rs/wgpu/latest/wgpu/struct.Limits.html). The `limits` field describes the limit of certain types of resources that we can create. We'll use the defaults for this tutorial, so we can support most devices. You can view a list of limits [here](https://docs.rs/wgpu/latest/wgpu/struct.Limits.html).
```rust ```rust
let surface_caps = surface.get_capabilities(&adapter);
// Shader code in this tutorial assumes an Srgb surface texture. Using a different
// one will result all the colors comming out darker. If you want to support non
// Srgb surfaces, you'll need to account for that when drawing to the frame.
let surface_format = surface_caps.formats.iter()
.copied()
.filter(|f| f.describe().srgb)
.next()
.unwrap_or(surface_caps.formats[0]);
let config = wgpu::SurfaceConfiguration { let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT, usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0], format: surface_format,
width: size.width, width: size.width,
height: size.height, height: size.height,
present_mode: wgpu::PresentMode::Fifo, present_mode: surface_caps.present_modes[0],
alpha_mode: wgpu::CompositeAlphaMode::Auto, alpha_mode: surface_caps.alpha_modes[0],
view_formats: vec![],
}; };
surface.configure(&device, &config); surface.configure(&device, &config);
``` ```
@ -163,7 +178,7 @@ Here we are defining a config for our surface. This will define how the surface
The `usage` field describes how `SurfaceTexture`s will be used. `RENDER_ATTACHMENT` specifies that the textures will be used to write to the screen (we'll talk about more `TextureUsages`s later). The `usage` field describes how `SurfaceTexture`s will be used. `RENDER_ATTACHMENT` specifies that the textures will be used to write to the screen (we'll talk about more `TextureUsages`s later).
The `format` defines how `SurfaceTexture`s will be stored on the gpu. `surface.get_supported_formats(&adapter)` returns a `Vec` of the formats that are supported by that surface. While a surface may support many formats, it usually has a format that it prefers, in which case it places that format first in the returned `Vec`. We use the format in the first position (`[0]`) to get the best format to use for that particular surface. The `format` defines how `SurfaceTexture`s will be stored on the gpu. We can get a supported format from the `SurfaceCapabilities`.
`width` and `height` are the width and the height in pixels of a `SurfaceTexture`. This should usually be the width and the height of the window. `width` and `height` are the width and the height in pixels of a `SurfaceTexture`. This should usually be the width and the height of the window.
@ -175,16 +190,20 @@ Make sure that the width and height of the `SurfaceTexture` are not 0, as that c
<div class="note"> <div class="note">
If you want to let your users pick what `PresentMode` they use, you can use [Surface::get_supported_modes()](https://docs.rs/wgpu/latest/wgpu/struct.Surface.html#method.get_supported_modes) to get a list of all the `PresentMode`s the surface supports: If you want to let your users pick what `PresentMode` they use, you can use [SurfaceCapabilities::present_modes](https://docs.rs/wgpu/latest/wgpu/struct.SurfaceCapabilities.html#structfield.present_modes) to get a list of all the `PresentMode`s the surface supports:
```rust ```rust
let modes = surface.get_supported_modes(&adapter); let modes = &surface_caps.present_modes;
``` ```
Regardless, `PresentMode::Fifo` will always be supported, and `PresentMode::AutoVsync` and `PresentMode::AutoNoVsync` have fallback support and therefore will work on all platforms. Regardless, `PresentMode::Fifo` will always be supported, and `PresentMode::AutoVsync` and `PresentMode::AutoNoVsync` have fallback support and therefore will work on all platforms.
</div> </div>
`alpha_mode` is honestly not something I'm familiar with. I believe it has something to do with transparent windows, but feel free to open a pull request. For now we'll just use the first `AlphaMode` in the list given by `surface_caps`.
`view_formats` is a list of `TextureFormat`s that you can use when creating `TextureView`s (we'll cover those briefly later in the this tutorial as well as more in depth [in the texture tutorial](../beginner/tutorial5-textures)). As of writing this means that if your surface is srgb color space, you can create a texture view that uses a linear color space.
Now that we've configured our surface properly we can add these new fields at the end of the method. Now that we've configured our surface properly we can add these new fields at the end of the method.
```rust ```rust
@ -244,13 +263,13 @@ cfg-if = "1"
winit = "0.27" winit = "0.27"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
wgpu = "0.14" wgpu = "0.15"
pollster = "0.2" pollster = "0.2"
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
console_error_panic_hook = "0.1.6" console_error_panic_hook = "0.1.6"
console_log = "0.2.0" console_log = "0.2.0"
wgpu = { version = "0.14", features = ["webgl"]} wgpu = { version = "0.15", features = ["webgl"]}
wasm-bindgen = "0.2" wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4" wasm-bindgen-futures = "0.4"
web-sys = { version = "0.3", features = [ web-sys = { version = "0.3", features = [

@ -65,6 +65,14 @@ let diffuse_texture = device.create_texture(
// COPY_DST means that we want to copy data to this texture // COPY_DST means that we want to copy data to this texture
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
label: Some("diffuse_texture"), label: Some("diffuse_texture"),
// This is the same as with the SurfaceConfig. It
// specifies what texture formats can be used to
// create TextureViews for this texture. The base
// texture format (Rgba8UnormSrgb in this case) is
// always supported. Note that using a different
// texture format is not supported on the WebGL2
// backend.
view_formats: &[],
} }
); );
``` ```
@ -442,7 +450,7 @@ winit = "0.27"
env_logger = "0.10" env_logger = "0.10"
log = "0.4" log = "0.4"
pollster = "0.2" pollster = "0.2"
wgpu = "0.14" wgpu = "0.15"
bytemuck = { version = "1.12", features = [ "derive" ] } bytemuck = { version = "1.12", features = [ "derive" ] }
anyhow = "1.0" # NEW! anyhow = "1.0" # NEW!
``` ```
@ -493,6 +501,7 @@ impl Texture {
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb, format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
} }
); );

@ -442,6 +442,12 @@ pub fn from_image(
is_normal_map: bool, // NEW! is_normal_map: bool, // NEW!
) -> Result<Self> { ) -> Result<Self> {
// ... // ...
// NEW!
let format = if is_normal_map {
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
};
let texture = device.create_texture(&wgpu::TextureDescriptor { let texture = device.create_texture(&wgpu::TextureDescriptor {
label, label,
size, size,
@ -449,12 +455,9 @@ pub fn from_image(
sample_count: 1, sample_count: 1,
dimension: wgpu::TextureDimension::D2, dimension: wgpu::TextureDimension::D2,
// UPDATED! // UPDATED!
format: if is_normal_map { format,
wgpu::TextureFormat::Rgba8Unorm
} else {
wgpu::TextureFormat::Rgba8UnormSrgb
},
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
}); });
// ... // ...

@ -14,7 +14,7 @@ This is not an in-depth guide on how to use Imgui. But here are some of the basi
```toml ```toml
imgui = "0.7" imgui = "0.7"
imgui-wgpu = "0.14" imgui-wgpu = "0.15"
imgui-winit-support = "0.7" imgui-winit-support = "0.7"
``` ```

@ -2,6 +2,12 @@
![](./pong.png) ![](./pong.png)
<div class="warn">
Currently not working, this will be updated when [wgpu_glyph gets updated to 0.15](https://github.com/hecrj/wgpu_glyph/pull/95).
</div>
Practically the "Hello World!" of games. Pong has been remade thousands of times. I know Pong. You know Pong. We all know Pong. That being said, this time I wanted to put in a little more effort than most people do. This showcase has a basic menu system, sounds, and different game states. Practically the "Hello World!" of games. Pong has been remade thousands of times. I know Pong. You know Pong. We all know Pong. That being said, this time I wanted to put in a little more effort than most people do. This showcase has a basic menu system, sounds, and different game states.
The architecture is not the best as I prescribed to the "get things done" mentality. If I were to redo this project, I'd change a lot of things. Regardless, let's get into the postmortem. The architecture is not the best as I prescribed to the "get things done" mentality. If I were to redo this project, I'd change a lot of things. Regardless, let's get into the postmortem.
@ -268,7 +274,7 @@ anyhow = "1.0"
bytemuck = { version = "1.12", features = [ "derive" ] } bytemuck = { version = "1.12", features = [ "derive" ] }
cgmath = "0.18" cgmath = "0.18"
pollster = "0.2" pollster = "0.2"
wgpu = { version = "0.14", features = ["spirv"]} wgpu = { version = "0.15", features = ["spirv"]}
wgpu_glyph = "0.17" wgpu_glyph = "0.17"
rand = "0.8" rand = "0.8"
rodio = { version = "0.15", default-features = false, features = ["wav"] } rodio = { version = "0.15", default-features = false, features = ["wav"] }
@ -287,7 +293,7 @@ web-sys = { version = "0.3.53", features = [
"Window", "Window",
"Element", "Element",
]} ]}
wgpu = { version = "0.14", features = ["spirv", "webgl"]} wgpu = { version = "0.15", features = ["spirv", "webgl"]}
[build-dependencies] [build-dependencies]
anyhow = "1.0" anyhow = "1.0"

@ -100,7 +100,7 @@ Update dependencies to support SPIR-V module.
[dependencies] [dependencies]
image = "0.23" image = "0.23"
shaderc = "0.7" shaderc = "0.7"
wgpu = { version = "0.14", features = ["spirv"] } wgpu = { version = "0.15", features = ["spirv"] }
pollster = "0.2" pollster = "0.2"
``` ```

Loading…
Cancel
Save