From 9d46e08cc7cfc795f83d07e989bc47f463237ee1 Mon Sep 17 00:00:00 2001 From: Lucas Kent Date: Sun, 28 Oct 2018 14:02:29 +1100 Subject: [PATCH] Cleanup examples (#1096) * replaced `.expect()` that provided no useful information with `.unwrap()` * used `use` consistently (all types are `use`d all functions have the parent module `use`d) * other formatting consistencies --- .gitignore | 3 +- examples/src/bin/basic-compute-shader.rs | 36 ++-- examples/src/bin/deferred/main.rs | 93 ++++----- examples/src/bin/image/main.rs | 155 +++++++------- examples/src/bin/msaa-renderpass.rs | 61 +++--- examples/src/bin/push-constants.rs | 40 ++-- examples/src/bin/runtime-shader/main.rs | 200 ++++++++----------- examples/src/bin/specialization-constants.rs | 29 +-- examples/src/bin/teapot/main.rs | 55 ++--- examples/src/bin/tessellation.rs | 89 ++++----- examples/src/bin/triangle.rs | 119 ++++++----- vulkano-shaders/src/lib.rs | 4 - 12 files changed, 396 insertions(+), 488 deletions(-) diff --git a/.gitignore b/.gitignore index 2ffecd4d..e68133bd 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ target /Cargo.lock -.cargo \ No newline at end of file +.cargo +examples/src/bin/triangle.png diff --git a/examples/src/bin/basic-compute-shader.rs b/examples/src/bin/basic-compute-shader.rs index 5d8184c4..d23dc2b0 100644 --- a/examples/src/bin/basic-compute-shader.rs +++ b/examples/src/bin/basic-compute-shader.rs @@ -17,17 +17,14 @@ extern crate vulkano; extern crate vulkano_shaders; -use vulkano::buffer::BufferUsage; -use vulkano::buffer::CpuAccessibleBuffer; +use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer}; use vulkano::command_buffer::AutoCommandBufferBuilder; use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; -use vulkano::device::Device; -use vulkano::device::DeviceExtensions; -use vulkano::instance::Instance; -use vulkano::instance::InstanceExtensions; +use vulkano::device::{Device, DeviceExtensions}; +use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice}; use vulkano::pipeline::ComputePipeline; -use vulkano::sync::now; use vulkano::sync::GpuFuture; +use vulkano::sync; use std::sync::Arc; @@ -52,12 +49,10 @@ void main() { fn main() { // As with other examples, the first step is to create an instance. - let instance = Instance::new(None, &InstanceExtensions::none(), None) - .expect("failed to create Vulkan instance"); + let instance = Instance::new(None, &InstanceExtensions::none(), None).unwrap(); // Choose which physical device to use. - let physical = vulkano::instance::PhysicalDevice::enumerate(&instance) - .next().expect("no device available"); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); // Choose the queue of the physical device which is going to run our compute operation. // @@ -66,10 +61,8 @@ fn main() { let queue_family = physical.queue_families().find(|&q| q.supports_compute()).unwrap(); // Now initializing the device. - let (device, mut queues) = { - Device::new(physical, physical.supported_features(), &DeviceExtensions::none(), - [(queue_family, 0.5)].iter().cloned()).expect("failed to create device") - }; + let (device, mut queues) = Device::new(physical, physical.supported_features(), + &DeviceExtensions::none(), [(queue_family, 0.5)].iter().cloned()).unwrap(); // Since we can request multiple queues, the `queues` variable is in fact an iterator. In this // example we use only one queue, so we just retrieve the first and only element of the @@ -97,10 +90,8 @@ fn main() { // If you are familiar with graphics pipeline, the principle is the same except that compute // pipelines are much simpler to create. let pipeline = Arc::new({ - let shader = cs::Shader::load(device.clone()) - .expect("failed to create shader module"); - ComputePipeline::new(device.clone(), &shader.main_entry_point(), &()) - .expect("failed to create compute pipeline") + let shader = cs::Shader::load(device.clone()).unwrap(); + ComputePipeline::new(device.clone(), &shader.main_entry_point(), &()).unwrap() }); // We start by creating the buffer that will store the data. @@ -108,8 +99,7 @@ fn main() { // Iterator that produces the data. let data_iter = (0 .. 65536u32).map(|n| n); // Builds the buffer and fills it with this iterator. - CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), - data_iter).expect("failed to create buffer") + CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap() }; // In order to let the shader access the buffer, we need to build a *descriptor set* that @@ -140,7 +130,7 @@ fn main() { // Let's execute this command buffer now. // To do so, we TODO: this is a bit clumsy, probably needs a shortcut - let future = now(device.clone()) + let future = sync::now(device.clone()) .then_execute(queue.clone(), command_buffer).unwrap() // This line instructs the GPU to signal a *fence* once the command buffer has finished @@ -166,7 +156,7 @@ fn main() { // Now that the GPU is done, the content of the buffer should have been modified. Let's // check it out. // The call to `read()` would return an error if the buffer was still in use by the GPU. - let data_buffer_content = data_buffer.read().expect("failed to lock buffer for reading"); + let data_buffer_content = data_buffer.read().unwrap(); for n in 0 .. 65536u32 { assert_eq!(data_buffer_content[n as usize], n * 12); } diff --git a/examples/src/bin/deferred/main.rs b/examples/src/bin/deferred/main.rs index cfd5e155..7ea0208b 100644 --- a/examples/src/bin/deferred/main.rs +++ b/examples/src/bin/deferred/main.rs @@ -33,18 +33,16 @@ extern crate vulkano_shaders; extern crate winit; extern crate vulkano_win; +use vulkano::device::{Device, DeviceExtensions}; +use vulkano::instance::{Instance, PhysicalDevice}; +use vulkano::swapchain::{AcquireError, PresentMode, SurfaceTransform, Swapchain, SwapchainCreationError}; +use vulkano::swapchain; +use vulkano::sync::{GpuFuture, FlushError}; +use vulkano::sync; + use vulkano_win::VkSurfaceBuild; -use vulkano::device::Device; -use vulkano::instance::Instance; -use vulkano::swapchain; -use vulkano::swapchain::PresentMode; -use vulkano::swapchain::SurfaceTransform; -use vulkano::swapchain::Swapchain; -use vulkano::swapchain::AcquireError; -use vulkano::swapchain::SwapchainCreationError; -use vulkano::sync::now; -use vulkano::sync::GpuFuture; +use winit::{EventsLoop, WindowBuilder, Event, WindowEvent}; use cgmath::Matrix4; use cgmath::SquareMatrix; @@ -53,68 +51,61 @@ use cgmath::Vector3; mod frame; mod triangle_draw_system; +use frame::*; +use triangle_draw_system::*; + fn main() { // Basic initialization. See the triangle example if you want more details about this. - let instance = { - let extensions = vulkano_win::required_extensions(); - Instance::new(None, &extensions, None).expect("failed to create Vulkan instance") - }; - let physical = vulkano::instance::PhysicalDevice::enumerate(&instance) - .next().expect("no device available"); + let extensions = vulkano_win::required_extensions(); + let instance = Instance::new(None, &extensions, None).unwrap(); - let mut events_loop = winit::EventsLoop::new(); - let surface = winit::WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); + + let mut events_loop = EventsLoop::new(); + let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); let window = surface.window(); let queue_family = physical.queue_families().find(|&q| { q.supports_graphics() && surface.is_supported(q).unwrap_or(false) }).expect("couldn't find a graphical queue family"); - let (device, mut queues) = { - let device_ext = vulkano::device::DeviceExtensions { - khr_swapchain: true, - .. vulkano::device::DeviceExtensions::none() - }; - - Device::new(physical, physical.supported_features(), &device_ext, - [(queue_family, 0.5)].iter().cloned()).expect("failed to create device") - }; - + let device_ext = DeviceExtensions { khr_swapchain: true, .. DeviceExtensions::none() }; + let (device, mut queues) = Device::new(physical, physical.supported_features(), &device_ext, + [(queue_family, 0.5)].iter().cloned()).unwrap(); let queue = queues.next().unwrap(); - let mut dimensions; - let (mut swapchain, mut images) = { - let caps = surface.capabilities(physical) - .expect("failed to get surface capabilities"); - let dimensions = if let Some(dimensions) = window.get_inner_size() { + let caps = surface.capabilities(physical).unwrap(); + + let usage = caps.supported_usage_flags; + let alpha = caps.supported_composite_alpha.iter().next().unwrap(); + let format = caps.supported_formats[0].0; + + let initial_dimensions = if let Some(dimensions) = window.get_inner_size() { let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); [dimensions.0, dimensions.1] } else { return; }; - let alpha = caps.supported_composite_alpha.iter().next().unwrap(); - let format = caps.supported_formats[0].0; + Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format, - dimensions, 1, caps.supported_usage_flags, &queue, - SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, - None).expect("failed to create swapchain") + initial_dimensions, 1, usage, &queue, SurfaceTransform::Identity, alpha, + PresentMode::Fifo, true, None).unwrap() }; // Here is the basic initialization for the deferred system. - let mut frame_system = frame::FrameSystem::new(queue.clone(), swapchain.format()); - let triangle_draw_system = triangle_draw_system::TriangleDrawSystem::new(queue.clone(), - frame_system.deferred_subpass()); + let mut frame_system = FrameSystem::new(queue.clone(), swapchain.format()); + let triangle_draw_system = TriangleDrawSystem::new(queue.clone(), frame_system.deferred_subpass()); let mut recreate_swapchain = false; - let mut previous_frame_end = Box::new(now(device.clone())) as Box; + let mut previous_frame_end = Box::new(sync::now(device.clone())) as Box; loop { previous_frame_end.cleanup_finished(); if recreate_swapchain { - dimensions = if let Some(dimensions) = window.get_inner_size() { + let dimensions = if let Some(dimensions) = window.get_inner_size() { let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); [dimensions.0, dimensions.1] } else { @@ -148,18 +139,18 @@ fn main() { let mut after_future = None; while let Some(pass) = frame.next_pass() { match pass { - frame::Pass::Deferred(mut draw_pass) => { + Pass::Deferred(mut draw_pass) => { let cb = triangle_draw_system.draw(draw_pass.viewport_dimensions()); draw_pass.execute(cb); } - frame::Pass::Lighting(mut lighting) => { + Pass::Lighting(mut lighting) => { lighting.ambient_light([0.1, 0.1, 0.1]); lighting.directional_light(Vector3::new(0.2, -0.1, -0.7), [0.6, 0.6, 0.6]); lighting.point_light(Vector3::new(0.5, -0.5, -0.1), [1.0, 0.0, 0.0]); lighting.point_light(Vector3::new(-0.9, 0.2, -0.15), [0.0, 1.0, 0.0]); lighting.point_light(Vector3::new(0.0, 0.5, -0.05), [0.0, 0.0, 1.0]); } - frame::Pass::Finished(af) => { + Pass::Finished(af) => { after_future = Some(af); } } @@ -173,21 +164,21 @@ fn main() { Ok(future) => { previous_frame_end = Box::new(future) as Box<_>; } - Err(vulkano::sync::FlushError::OutOfDate) => { + Err(FlushError::OutOfDate) => { recreate_swapchain = true; - previous_frame_end = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>; } Err(e) => { println!("{:?}", e); - previous_frame_end = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>; } } let mut done = false; events_loop.poll_events(|ev| { match ev { - winit::Event::WindowEvent { event: winit::WindowEvent::CloseRequested, .. } => done = true, - winit::Event::WindowEvent { event: winit::WindowEvent::Resized(_), .. } => recreate_swapchain = true, + Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => done = true, + Event::WindowEvent { event: WindowEvent::Resized(_), .. } => recreate_swapchain = true, _ => () } }); diff --git a/examples/src/bin/image/main.rs b/examples/src/bin/image/main.rs index 84d9863f..bac48477 100644 --- a/examples/src/bin/image/main.rs +++ b/examples/src/bin/image/main.rs @@ -7,23 +7,36 @@ // notice may not be copied, modified, or distributed except // according to those terms. -extern crate cgmath; -extern crate image; -extern crate winit; #[macro_use] extern crate vulkano; extern crate vulkano_shaders; extern crate vulkano_win; +extern crate winit; +extern crate cgmath; +extern crate image; + +use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer}; +use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState}; +use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; +use vulkano::device::{Device, DeviceExtensions}; +use vulkano::format::Format; +use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, Subpass, RenderPassAbstract}; +use vulkano::image::{SwapchainImage, ImmutableImage, Dimensions}; +use vulkano::instance::{Instance, PhysicalDevice}; +use vulkano::pipeline::GraphicsPipeline; +use vulkano::pipeline::viewport::Viewport; +use vulkano::sampler::{Sampler, SamplerAddressMode, Filter, MipmapMode}; +use vulkano::swapchain::{AcquireError, PresentMode, SurfaceTransform, Swapchain, SwapchainCreationError}; +use vulkano::swapchain; +use vulkano::sync::{GpuFuture, FlushError}; +use vulkano::sync; use vulkano_win::VkSurfaceBuild; -use vulkano::sync::GpuFuture; -use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, RenderPassAbstract}; -use vulkano::command_buffer::DynamicState; -use vulkano::image::SwapchainImage; -use vulkano::pipeline::viewport::Viewport; -use winit::Window; +use winit::{EventsLoop, Window, WindowBuilder, Event, WindowEvent}; + +use image::ImageFormat; use std::sync::Arc; @@ -32,33 +45,32 @@ fn main() { // `triangle` example if you haven't done so yet. let extensions = vulkano_win::required_extensions(); - let instance = vulkano::instance::Instance::new(None, &extensions, None).expect("failed to create instance"); + let instance = Instance::new(None, &extensions, None).unwrap(); - let physical = vulkano::instance::PhysicalDevice::enumerate(&instance) - .next().expect("no device available"); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); println!("Using device: {} (type: {:?})", physical.name(), physical.ty()); - let mut events_loop = winit::EventsLoop::new(); - let surface = winit::WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); + let mut events_loop = EventsLoop::new(); + let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); let window = surface.window(); - let queue_family = physical.queue_families().find(|&q| q.supports_graphics() && - surface.is_supported(q).unwrap_or(false)) - .expect("couldn't find a graphical queue family"); + let queue_family = physical.queue_families().find(|&q| + q.supports_graphics() && surface.is_supported(q).unwrap_or(false) + ).unwrap(); - let device_ext = vulkano::device::DeviceExtensions { - khr_swapchain: true, - .. vulkano::device::DeviceExtensions::none() - }; - let (device, mut queues) = vulkano::device::Device::new(physical, physical.supported_features(), - &device_ext, [(queue_family, 0.5)].iter().cloned()) - .expect("failed to create device"); + let device_ext = DeviceExtensions { khr_swapchain: true, .. DeviceExtensions::none() }; + let (device, mut queues) = Device::new(physical, physical.supported_features(), &device_ext, + [(queue_family, 0.5)].iter().cloned()).unwrap(); let queue = queues.next().unwrap(); let (mut swapchain, images) = { - let caps = surface.capabilities(physical).expect("failed to get surface capabilities"); + let caps = surface.capabilities(physical).unwrap(); - let dimensions = if let Some(dimensions) = window.get_inner_size() { + let usage = caps.supported_usage_flags; + let alpha = caps.supported_composite_alpha.iter().next().unwrap(); + let format = caps.supported_formats[0].0; + + let initial_dimensions = if let Some(dimensions) = window.get_inner_size() { // convert to physical pixels let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); [dimensions.0, dimensions.1] @@ -66,15 +78,10 @@ fn main() { // The window no longer exists so exit the application. return; }; - let usage = caps.supported_usage_flags; - let alpha = caps.supported_composite_alpha.iter().next().unwrap(); - let format = caps.supported_formats[0].0; - vulkano::swapchain::Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, - format, dimensions, 1, - usage, &queue, vulkano::swapchain::SurfaceTransform::Identity, - alpha, - vulkano::swapchain::PresentMode::Fifo, true, None).expect("failed to create swapchain") + Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format, + initial_dimensions, 1, usage, &queue, SurfaceTransform::Identity, alpha, + PresentMode::Fifo, true, None).unwrap() }; @@ -82,17 +89,19 @@ fn main() { struct Vertex { position: [f32; 2] } impl_vertex!(Vertex, position); - let vertex_buffer = vulkano::buffer::cpu_access::CpuAccessibleBuffer::<[Vertex]> - ::from_iter(device.clone(), vulkano::buffer::BufferUsage::all(), - [ - Vertex { position: [-0.5, -0.5 ] }, - Vertex { position: [-0.5, 0.5 ] }, - Vertex { position: [ 0.5, -0.5 ] }, - Vertex { position: [ 0.5, 0.5 ] }, - ].iter().cloned()).expect("failed to create buffer"); + let vertex_buffer = CpuAccessibleBuffer::<[Vertex]>::from_iter( + device.clone(), + BufferUsage::all(), + [ + Vertex { position: [-0.5, -0.5 ] }, + Vertex { position: [-0.5, 0.5 ] }, + Vertex { position: [ 0.5, -0.5 ] }, + Vertex { position: [ 0.5, 0.5 ] }, + ].iter().cloned() + ).unwrap(); - let vs = vs::Shader::load(device.clone()).expect("failed to create shader module"); - let fs = fs::Shader::load(device.clone()).expect("failed to create shader module"); + let vs = vs::Shader::load(device.clone()).unwrap(); + let fs = fs::Shader::load(device.clone()).unwrap(); let render_pass = Arc::new( single_pass_renderpass!(device.clone(), @@ -113,36 +122,33 @@ fn main() { let (texture, tex_future) = { let image = image::load_from_memory_with_format(include_bytes!("image_img.png"), - image::ImageFormat::PNG).unwrap().to_rgba(); + ImageFormat::PNG).unwrap().to_rgba(); let image_data = image.into_raw().clone(); - vulkano::image::immutable::ImmutableImage::from_iter( + ImmutableImage::from_iter( image_data.iter().cloned(), - vulkano::image::Dimensions::Dim2d { width: 93, height: 93 }, - vulkano::format::R8G8B8A8Srgb, - queue.clone()).unwrap() + Dimensions::Dim2d { width: 93, height: 93 }, + Format::R8G8B8A8Srgb, + queue.clone() + ).unwrap() }; + let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear, + MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat, + SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap(); - let sampler = vulkano::sampler::Sampler::new(device.clone(), vulkano::sampler::Filter::Linear, - vulkano::sampler::Filter::Linear, vulkano::sampler::MipmapMode::Nearest, - vulkano::sampler::SamplerAddressMode::Repeat, - vulkano::sampler::SamplerAddressMode::Repeat, - vulkano::sampler::SamplerAddressMode::Repeat, - 0.0, 1.0, 0.0, 0.0).unwrap(); - - let pipeline = Arc::new(vulkano::pipeline::GraphicsPipeline::start() + let pipeline = Arc::new(GraphicsPipeline::start() .vertex_input_single_buffer::() .vertex_shader(vs.main_entry_point(), ()) .triangle_strip() .viewports_dynamic_scissors_irrelevant(1) .fragment_shader(fs.main_entry_point(), ()) .blend_alpha_blending() - .render_pass(vulkano::framebuffer::Subpass::from(render_pass.clone(), 0).unwrap()) + .render_pass(Subpass::from(render_pass.clone(), 0).unwrap()) .build(device.clone()) .unwrap()); - let set = Arc::new(vulkano::descriptor::descriptor_set::PersistentDescriptorSet::start(pipeline.clone(), 0) + let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0) .add_sampled_image(texture.clone(), sampler.clone()).unwrap() .build().unwrap() ); @@ -151,7 +157,6 @@ fn main() { let mut framebuffers = window_size_dependent_setup(&images, render_pass.clone(), &mut dynamic_state); let mut recreate_swapchain = false; - let mut previous_frame_end = Box::new(tex_future) as Box; loop { @@ -166,7 +171,7 @@ fn main() { let (new_swapchain, new_images) = match swapchain.recreate_with_dimension(dimensions) { Ok(r) => r, - Err(vulkano::swapchain::SwapchainCreationError::UnsupportedDimensions) => continue, + Err(SwapchainCreationError::UnsupportedDimensions) => continue, Err(err) => panic!("{:?}", err) }; @@ -176,24 +181,20 @@ fn main() { recreate_swapchain = false; } - let (image_num, future) = match vulkano::swapchain::acquire_next_image(swapchain.clone(), None) { + let (image_num, future) = match swapchain::acquire_next_image(swapchain.clone(), None) { Ok(r) => r, - Err(vulkano::swapchain::AcquireError::OutOfDate) => { + Err(AcquireError::OutOfDate) => { recreate_swapchain = true; continue; } Err(err) => panic!("{:?}", err) }; - let cb = vulkano::command_buffer::AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()) + let clear_values = vec!([0.0, 0.0, 1.0, 1.0].into()); + let cb = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()) .unwrap() - .begin_render_pass( - framebuffers[image_num].clone(), false, - vec![[0.0, 0.0, 1.0, 1.0].into()]).unwrap() - .draw(pipeline.clone(), - &dynamic_state, - vertex_buffer.clone(), - set.clone(), ()).unwrap() + .begin_render_pass(framebuffers[image_num].clone(), false, clear_values).unwrap() + .draw(pipeline.clone(), &dynamic_state, vertex_buffer.clone(), set.clone(), ()).unwrap() .end_render_pass().unwrap() .build().unwrap(); @@ -206,21 +207,21 @@ fn main() { Ok(future) => { previous_frame_end = Box::new(future) as Box<_>; } - Err(vulkano::sync::FlushError::OutOfDate) => { + Err(FlushError::OutOfDate) => { recreate_swapchain = true; - previous_frame_end = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>; } Err(e) => { println!("{:?}", e); - previous_frame_end = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>; } } let mut done = false; events_loop.poll_events(|ev| { match ev { - winit::Event::WindowEvent { event: winit::WindowEvent::CloseRequested, .. } => done = true, - winit::Event::WindowEvent { event: winit::WindowEvent::Resized(_), .. } => recreate_swapchain = true, + Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => done = true, + Event::WindowEvent { event: WindowEvent::Resized(_), .. } => recreate_swapchain = true, _ => () } }); @@ -228,7 +229,7 @@ fn main() { } } -/// This method is called once during initialization then again whenever the window is resized +/// This method is called once during initialization, then again whenever the window is resized fn window_size_dependent_setup( images: &[Arc>], render_pass: Arc, diff --git a/examples/src/bin/msaa-renderpass.rs b/examples/src/bin/msaa-renderpass.rs index 1ea10d05..a68dfd7e 100644 --- a/examples/src/bin/msaa-renderpass.rs +++ b/examples/src/bin/msaa-renderpass.rs @@ -72,25 +72,17 @@ extern crate vulkano_shaders; use std::sync::Arc; use image::ImageBuffer; use image::Rgba; -use vulkano::buffer::BufferUsage; -use vulkano::buffer::CpuAccessibleBuffer; -use vulkano::command_buffer::AutoCommandBufferBuilder; -use vulkano::command_buffer::CommandBuffer; -use vulkano::command_buffer::DynamicState; -use vulkano::device::Device; -use vulkano::device::DeviceExtensions; +use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer}; +use vulkano::command_buffer::{AutoCommandBufferBuilder, CommandBuffer, DynamicState}; +use vulkano::device::{Device, DeviceExtensions}; use vulkano::format::Format; -use vulkano::framebuffer::Framebuffer; -use vulkano::framebuffer::Subpass; -use vulkano::image::AttachmentImage; -use vulkano::image::Dimensions; -use vulkano::image::StorageImage; -use vulkano::instance::Instance; -use vulkano::instance::InstanceExtensions; -use vulkano::instance::PhysicalDevice; +use vulkano::framebuffer::{Framebuffer, Subpass}; +use vulkano::image::{AttachmentImage, Dimensions, StorageImage}; +use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice}; use vulkano::pipeline::GraphicsPipeline; use vulkano::pipeline::viewport::Viewport; use vulkano::sync::GpuFuture; +use vulkano::format::ClearValue; mod vs { vulkano_shaders::shader!{ @@ -122,34 +114,30 @@ void main() { fn main() { // The usual Vulkan initialization. - let instance = Instance::new(None, &InstanceExtensions::none(), None) - .expect("failed to create instance"); - let physical = PhysicalDevice::enumerate(&instance).next().expect("no device available"); - let queue_family = physical.queue_families() - .find(|&q| q.supports_graphics()) - .expect("couldn't find a graphical queue family"); - let (device, mut queues) = { - Device::new(physical, physical.supported_features(), &DeviceExtensions::none(), - [(queue_family, 0.5)].iter().cloned()).expect("failed to create device") - }; + let instance = Instance::new(None, &InstanceExtensions::none(), None).unwrap(); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); + let queue_family = physical.queue_families().find(|&q| q.supports_graphics()).unwrap(); + let (device, mut queues) = Device::new(physical, physical.supported_features(), + &DeviceExtensions::none(), [(queue_family, 0.5)].iter().cloned()).unwrap(); let queue = queues.next().unwrap(); // Creating our intermediate multisampled image. // // As explained in the introduction, we pass the same dimensions and format as for the final // image. But we also pass the number of samples-per-pixel, which is 4 here. - let intermediary = AttachmentImage::transient_multisampled(device.clone(), [1024, 1024], - 4, Format::R8G8B8A8Unorm).unwrap(); + let intermediary = AttachmentImage::transient_multisampled(device.clone(), + [1024, 1024], 4, Format::R8G8B8A8Unorm).unwrap(); // This is the final image that will receive the anti-aliased triangle. let image = StorageImage::new(device.clone(), Dimensions::Dim2d { width: 1024, height: 1024 }, - Format::R8G8B8A8Unorm, Some(queue.family())).unwrap(); + Format::R8G8B8A8Unorm, Some(queue.family())).unwrap(); // In this example, we are going to perform the *resolve* (ie. turning a multisampled image // into a non-multisampled one) as part of the render pass. This is the preferred method of // doing so, as it the advantage that the Vulkan implementation doesn't have to write the // content of the multisampled image back to memory at the end. - let render_pass = Arc::new(single_pass_renderpass!(device.clone(), + let render_pass = Arc::new(single_pass_renderpass!( + device.clone(), attachments: { // The first framebuffer attachment is the intermediary image. intermediary: { @@ -192,19 +180,20 @@ fn main() { // At the end of the example, we copy the content of `image` (ie. the final image) to a buffer, // then read the content of that buffer and save it to a PNG file. - let vs = vs::Shader::load(device.clone()).expect("failed to create shader module"); - let fs = fs::Shader::load(device.clone()).expect("failed to create shader module"); + let vs = vs::Shader::load(device.clone()).unwrap(); + let fs = fs::Shader::load(device.clone()).unwrap(); #[derive(Copy, Clone)] struct Vertex { position: [f32; 2], } impl_vertex!(Vertex, position); + let vertex1 = Vertex { position: [-0.5, -0.5] }; let vertex2 = Vertex { position: [ 0.0, 0.5] }; let vertex3 = Vertex { position: [ 0.5, -0.25] }; let vertex_buffer = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), - vec![vertex1, vertex2, vertex3].into_iter()).unwrap(); + vec![vertex1, vertex2, vertex3].into_iter()).unwrap(); let pipeline = Arc::new(GraphicsPipeline::start() .vertex_input_single_buffer::() @@ -225,11 +214,10 @@ fn main() { }; let buf = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), - (0 .. 1024 * 1024 * 4).map(|_| 0u8)) - .expect("failed to create buffer"); + (0 .. 1024 * 1024 * 4).map(|_| 0u8)).unwrap(); let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()).unwrap() - .begin_render_pass(framebuffer.clone(), false, vec![[0.0, 0.0, 1.0, 1.0].into(), vulkano::format::ClearValue::None]) + .begin_render_pass(framebuffer.clone(), false, vec![[0.0, 0.0, 1.0, 1.0].into(), ClearValue::None]) .unwrap() .draw(pipeline.clone(), &dynamic_state, vertex_buffer.clone(), (), ()) @@ -245,8 +233,7 @@ fn main() { .unwrap(); let finished = command_buffer.execute(queue.clone()).unwrap(); - finished.then_signal_fence_and_flush().unwrap() - .wait(None).unwrap(); + finished.then_signal_fence_and_flush().unwrap().wait(None).unwrap(); let buffer_content = buf.read().unwrap(); let image = ImageBuffer::, _>::from_raw(1024, 1024, &buffer_content[..]).unwrap(); diff --git a/examples/src/bin/push-constants.rs b/examples/src/bin/push-constants.rs index 32f06b41..65a36ba5 100644 --- a/examples/src/bin/push-constants.rs +++ b/examples/src/bin/push-constants.rs @@ -11,17 +11,14 @@ extern crate vulkano; extern crate vulkano_shaders; -use vulkano::buffer::BufferUsage; -use vulkano::buffer::CpuAccessibleBuffer; +use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer}; use vulkano::command_buffer::AutoCommandBufferBuilder; use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; -use vulkano::device::Device; -use vulkano::device::DeviceExtensions; -use vulkano::instance::Instance; -use vulkano::instance::InstanceExtensions; +use vulkano::device::{Device, DeviceExtensions}; +use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice}; use vulkano::pipeline::ComputePipeline; -use vulkano::sync::now; use vulkano::sync::GpuFuture; +use vulkano::sync; use std::sync::Arc; @@ -55,29 +52,26 @@ void main() { fn main() { let instance = Instance::new(None, &InstanceExtensions::none(), None).unwrap(); - let physical = vulkano::instance::PhysicalDevice::enumerate(&instance).next().unwrap(); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); let queue_family = physical.queue_families().find(|&q| q.supports_compute()).unwrap(); - let (device, mut queues) = { - Device::new(physical, physical.supported_features(), &DeviceExtensions::none(), - [(queue_family, 0.5)].iter().cloned()).expect("failed to create device") - }; + let (device, mut queues) = Device::new(physical, physical.supported_features(), + &DeviceExtensions::none(), [(queue_family, 0.5)].iter().cloned()).unwrap(); let queue = queues.next().unwrap(); - let shader = cs::Shader::load(device.clone()) - .expect("failed to create shader module"); + let shader = cs::Shader::load(device.clone()).unwrap(); let pipeline = Arc::new(ComputePipeline::new(device.clone(), &shader.main_entry_point(), &()).unwrap()); let data_buffer = { let data_iter = (0 .. 65536u32).map(|n| n); - CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), - data_iter).expect("failed to create buffer") + CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap() }; - let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0) - .add_buffer(data_buffer.clone()).unwrap() - .build().unwrap() + let set = Arc::new( + PersistentDescriptorSet::start(pipeline.clone(), 0) + .add_buffer(data_buffer.clone()).unwrap() + .build().unwrap() ); - // The `vulkano_shaders!` macro generates a struct with the correct representation of the push constants struct specified in the shader. + // The `vulkano_shaders::shaders!` macro generates a struct with the correct representation of the push constants struct specified in the shader. // Here we create an instance of the generated struct. let push_constants = cs::ty::PushConstantData { multiple: 1, @@ -88,18 +82,18 @@ fn main() { // For a compute pipeline, push constants are passed to the `dispatch` method. // For a graphics pipeline, push constants are passed to the `draw` and `draw_indexed` methods. // Note that there is no type safety for the push constants argument. - // So be careful to only pass an instance of the struct generated by the `vulkano_shaders!` macro. + // So be careful to only pass an instance of the struct generated by the `vulkano_shaders::shaders!` macro. let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()).unwrap() .dispatch([1024, 1, 1], pipeline.clone(), set.clone(), push_constants).unwrap() .build().unwrap(); - let future = now(device.clone()) + let future = sync::now(device.clone()) .then_execute(queue.clone(), command_buffer).unwrap() .then_signal_fence_and_flush().unwrap(); future.wait(None).unwrap(); - let data_buffer_content = data_buffer.read().expect("failed to lock buffer for reading"); + let data_buffer_content = data_buffer.read().unwrap(); for n in 0 .. 65536u32 { assert_eq!(data_buffer_content[n as usize], n * 1 + 1); } diff --git a/examples/src/bin/runtime-shader/main.rs b/examples/src/bin/runtime-shader/main.rs index 6b817477..2f8c4f90 100644 --- a/examples/src/bin/runtime-shader/main.rs +++ b/examples/src/bin/runtime-shader/main.rs @@ -34,7 +34,7 @@ use vulkano::descriptor::pipeline_layout::PipelineLayoutDesc; use vulkano::descriptor::pipeline_layout::PipelineLayoutDescPcRange; use vulkano::device::Device; use vulkano::device::DeviceExtensions; -use vulkano::format; +use vulkano::format::Format; use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, Subpass, RenderPassAbstract}; use vulkano::image::SwapchainImage; use vulkano::pipeline::GraphicsPipeline; @@ -65,77 +65,55 @@ pub struct Vertex { impl_vertex!(Vertex, position, color); fn main() { - let instance = vk::instance::Instance::new( - None, - &vulkano_win::required_extensions(), - None, - ).expect("no instance with surface extension"); - let physical = vk::instance::PhysicalDevice::enumerate(&instance) - .next() - .expect("no graphics device"); + let instance = vk::instance::Instance::new(None, &vulkano_win::required_extensions(), None).unwrap(); + let physical = vk::instance::PhysicalDevice::enumerate(&instance).next().unwrap(); + let mut events_loop = winit::EventsLoop::new(); let surface = winit::WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); let window = surface.window(); + + let queue_family = physical.queue_families().find(|&q| { + q.supports_graphics() && surface.is_supported(q).unwrap_or(false) + }).unwrap(); let (device, mut queues) = { - let graphical_queue_family = physical - .queue_families() - .find(|&q| q.supports_graphics() && surface.is_supported(q).unwrap_or(false)) - .expect("couldn't find a graphic queue family"); - let device_ext = DeviceExtensions { - khr_swapchain: true, - ..DeviceExtensions::none() - }; - Device::new( - physical.clone(), - physical.supported_features(), - &device_ext, - [(graphical_queue_family, 0.5)].iter().cloned(), - ).expect("failed to create device") + let device_ext = DeviceExtensions { khr_swapchain: true, .. DeviceExtensions::none() }; + Device::new(physical, physical.supported_features(), &device_ext, + [(queue_family, 0.5)].iter().cloned()).unwrap() + }; + let queue = queues.next().unwrap(); + + let initial_dimensions = if let Some(dimensions) = window.get_inner_size() { + let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); + [dimensions.0, dimensions.1] + } else { + return; }; - let graphics_queue = queues.next().unwrap(); let (mut swapchain, images) = { - let caps = surface - .capabilities(device.physical_device()) - .expect("failure to get surface capabilities"); + let caps = surface.capabilities(physical).unwrap(); + let usage = caps.supported_usage_flags; let alpha = caps.supported_composite_alpha.iter().next().unwrap(); let format = caps.supported_formats[0].0; - let dimensions = caps.current_extent.unwrap_or([1024, 768]); - let usage = caps.supported_usage_flags; - Swapchain::new( - device.clone(), - surface.clone(), - caps.min_image_count, - format, - dimensions, - 1, - usage, - &graphics_queue, - SurfaceTransform::Identity, - alpha, - PresentMode::Fifo, - true, - None, - ).expect("failed to create swapchain") + Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format, initial_dimensions, + 1, usage, &queue, SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, None).unwrap() }; - let render_pass = Arc::new( - single_pass_renderpass!( - device.clone(), attachments: { - color: { - load: Clear, - store: Store, - format: swapchain.format(), - samples: 1, - } - }, - pass: { - color: [color], - depth_stencil: {} + let render_pass = Arc::new(single_pass_renderpass!( + device.clone(), + attachments: { + color: { + load: Clear, + store: Store, + format: swapchain.format(), + samples: 1, } - ).unwrap(), - ); + }, + pass: { + color: [color], + depth_stencil: {} + } + ).unwrap()); let vs = { let mut f = File::open("src/bin/runtime-shader/vert.spv") @@ -155,10 +133,10 @@ fn main() { unsafe { ShaderModule::new(device.clone(), &v) }.unwrap() }; - // This structure will tell Vulkan how input entries of our vertex shader - // look like. + // This structure will tell Vulkan how input entries of our vertex shader look like #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] struct VertInput; + unsafe impl ShaderInterfaceDef for VertInput { type Iter = VertInputIter; @@ -166,8 +144,10 @@ fn main() { VertInputIter(0) } } + #[derive(Debug, Copy, Clone)] struct VertInputIter(u16); + impl Iterator for VertInputIter { type Item = ShaderInterfaceDefEntry; @@ -182,7 +162,7 @@ fn main() { self.0 += 1; return Some(ShaderInterfaceDefEntry { location: 1..2, - format: format::Format::R32G32B32Sfloat, + format: Format::R32G32B32Sfloat, name: Some(Cow::Borrowed("color")) }) } @@ -190,12 +170,13 @@ fn main() { self.0 += 1; return Some(ShaderInterfaceDefEntry { location: 0..1, - format: format::Format::R32G32Sfloat, + format: Format::R32G32Sfloat, name: Some(Cow::Borrowed("position")) }) } None } + #[inline] fn size_hint(&self) -> (usize, Option) { // We must return exact number of entries left in iterator. @@ -203,10 +184,12 @@ fn main() { (len, Some(len)) } } - impl ExactSizeIterator for VertInputIter { - } + + impl ExactSizeIterator for VertInputIter { } + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] struct VertOutput; + unsafe impl ShaderInterfaceDef for VertOutput { type Iter = VertOutputIter; @@ -214,10 +197,12 @@ fn main() { VertOutputIter(0) } } + // This structure will tell Vulkan how output entries (those passed to next // stage) of our vertex shader look like. #[derive(Debug, Copy, Clone)] struct VertOutputIter(u16); + impl Iterator for VertOutputIter { type Item = ShaderInterfaceDefEntry; @@ -227,20 +212,22 @@ fn main() { self.0 += 1; return Some(ShaderInterfaceDefEntry { location: 0..1, - format: format::Format::R32G32B32Sfloat, + format: Format::R32G32B32Sfloat, name: Some(Cow::Borrowed("v_color")) }) } None } + #[inline] fn size_hint(&self) -> (usize, Option) { let len = (1 - self.0) as usize; (len, Some(len)) } } - impl ExactSizeIterator for VertOutputIter { - } + + impl ExactSizeIterator for VertOutputIter { } + // This structure describes layout of this stage. #[derive(Debug, Copy, Clone)] struct VertLayout(ShaderStages); @@ -248,22 +235,13 @@ fn main() { // Number of descriptor sets it takes. fn num_sets(&self) -> usize { 0 } // Number of entries (bindings) in each set. - fn num_bindings_in_set(&self, set: usize) -> Option { - match set { _ => None, } - } + fn num_bindings_in_set(&self, _set: usize) -> Option { None } // Descriptor descriptions. - fn descriptor(&self, set: usize, binding: usize) -> Option { - match (set, binding) { _ => None, } - } + fn descriptor(&self, _set: usize, _binding: usize) -> Option { None } // Number of push constants ranges (think: number of push constants). fn num_push_constants_ranges(&self) -> usize { 0 } // Each push constant range in memory. - fn push_constants_range(&self, num: usize) -> Option { - if num != 0 || 0 == 0 { return None; } - Some(PipelineLayoutDescPcRange { offset: 0, - size: 0, - stages: ShaderStages::all() }) - } + fn push_constants_range(&self, _num: usize) -> Option { None } } // Same as with our vertex shader, but for fragment one instead. @@ -278,6 +256,7 @@ fn main() { } #[derive(Debug, Copy, Clone)] struct FragInputIter(u16); + impl Iterator for FragInputIter { type Item = ShaderInterfaceDefEntry; @@ -287,20 +266,22 @@ fn main() { self.0 += 1; return Some(ShaderInterfaceDefEntry { location: 0..1, - format: format::Format::R32G32B32Sfloat, + format: Format::R32G32B32Sfloat, name: Some(Cow::Borrowed("v_color")) }) } None } + #[inline] fn size_hint(&self) -> (usize, Option) { let len = (1 - self.0) as usize; (len, Some(len)) } } - impl ExactSizeIterator for FragInputIter { - } + + impl ExactSizeIterator for FragInputIter { } + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] struct FragOutput; unsafe impl ShaderInterfaceDef for FragOutput { @@ -310,8 +291,10 @@ fn main() { FragOutputIter(0) } } + #[derive(Debug, Copy, Clone)] struct FragOutputIter(u16); + impl Iterator for FragOutputIter { type Item = ShaderInterfaceDefEntry; @@ -323,7 +306,7 @@ fn main() { self.0 += 1; return Some(ShaderInterfaceDefEntry { location: 0..1, - format: format::Format::R32G32B32A32Sfloat, + format: Format::R32G32B32A32Sfloat, name: Some(Cow::Borrowed("f_color")) }) } @@ -335,26 +318,18 @@ fn main() { (len, Some(len)) } } - impl ExactSizeIterator for FragOutputIter { - } + + impl ExactSizeIterator for FragOutputIter { } + // Layout same as with vertex shader. #[derive(Debug, Copy, Clone)] struct FragLayout(ShaderStages); unsafe impl PipelineLayoutDesc for FragLayout { fn num_sets(&self) -> usize { 0 } - fn num_bindings_in_set(&self, set: usize) -> Option { - match set { _ => None, } - } - fn descriptor(&self, set: usize, binding: usize) -> Option { - match (set, binding) { _ => None, } - } + fn num_bindings_in_set(&self, _set: usize) -> Option { None } + fn descriptor(&self, _set: usize, _binding: usize) -> Option { None } fn num_push_constants_ranges(&self) -> usize { 0 } - fn push_constants_range(&self, num: usize) -> Option { - if num != 0 || 0 == 0 { return None; } - Some(PipelineLayoutDescPcRange { offset: 0, - size: 0, - stages: ShaderStages::all() }) - } + fn push_constants_range(&self, _num: usize) -> Option { None } } // NOTE: ShaderModule::*_shader_entry_point calls do not do any error @@ -405,7 +380,7 @@ fn main() { Vertex { position: [ 0.0, -1.0], color: [0.0, 1.0, 0.0] }, Vertex { position: [ 1.0, 1.0], color: [0.0, 0.0, 1.0] }, ].iter().cloned() - ).expect("failed to create vertex buffer"); + ).unwrap(); // NOTE: We don't create any descriptor sets in this example, but you should // note that passing wrong types, providing sets at wrong indexes will cause @@ -448,28 +423,17 @@ fn main() { Err(err) => panic!("{:?}", err) }; - let command_buffer = AutoCommandBufferBuilder::new( - device.clone(), - graphics_queue.family(), - ).unwrap() - .begin_render_pass( - framebuffers[image_num].clone(), - false, - vec![[0.0, 0.0, 0.0, 1.0].into()], - ).unwrap() - .draw( - graphics_pipeline.clone(), - &dynamic_state, - vertex_buffer.clone(), - (), - (), - ).unwrap() + + let clear_values = vec!([0.0, 0.0, 0.0, 1.0].into()); + let command_buffer = AutoCommandBufferBuilder::new(device.clone(), queue.family()).unwrap() + .begin_render_pass(framebuffers[image_num].clone(), false, clear_values).unwrap() + .draw(graphics_pipeline.clone(), &dynamic_state, vertex_buffer.clone(), (), ()).unwrap() .end_render_pass().unwrap() .build().unwrap(); let future = previous_frame_end.join(acquire_future) - .then_execute(graphics_queue.clone(), command_buffer).unwrap() - .then_swapchain_present(graphics_queue.clone(), swapchain.clone(), image_num) + .then_execute(queue.clone(), command_buffer).unwrap() + .then_swapchain_present(queue.clone(), swapchain.clone(), image_num) .then_signal_fence_and_flush(); match future { @@ -498,7 +462,7 @@ fn main() { } } -/// This method is called once during initialization then again whenever the window is resized +/// This method is called once during initialization, then again whenever the window is resized fn window_size_dependent_setup( images: &[Arc>], render_pass: Arc, diff --git a/examples/src/bin/specialization-constants.rs b/examples/src/bin/specialization-constants.rs index a24d130b..f25dc3a4 100644 --- a/examples/src/bin/specialization-constants.rs +++ b/examples/src/bin/specialization-constants.rs @@ -11,17 +11,14 @@ extern crate vulkano; extern crate vulkano_shaders; -use vulkano::buffer::BufferUsage; -use vulkano::buffer::CpuAccessibleBuffer; +use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer}; use vulkano::command_buffer::AutoCommandBufferBuilder; use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; -use vulkano::device::Device; -use vulkano::device::DeviceExtensions; -use vulkano::instance::Instance; -use vulkano::instance::InstanceExtensions; +use vulkano::device::{Device, DeviceExtensions}; +use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice}; use vulkano::pipeline::ComputePipeline; -use vulkano::sync::now; use vulkano::sync::GpuFuture; +use vulkano::sync; use std::sync::Arc; @@ -53,16 +50,13 @@ void main() { fn main() { let instance = Instance::new(None, &InstanceExtensions::none(), None).unwrap(); - let physical = vulkano::instance::PhysicalDevice::enumerate(&instance).next().unwrap(); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); let queue_family = physical.queue_families().find(|&q| q.supports_compute()).unwrap(); - let (device, mut queues) = { - Device::new(physical, physical.supported_features(), &DeviceExtensions::none(), - [(queue_family, 0.5)].iter().cloned()).expect("failed to create device") - }; + let (device, mut queues) = Device::new(physical, physical.supported_features(), + &DeviceExtensions::none(), [(queue_family, 0.5)].iter().cloned()).unwrap(); let queue = queues.next().unwrap(); - let shader = cs::Shader::load(device.clone()) - .expect("failed to create shader module"); + let shader = cs::Shader::load(device.clone()).unwrap(); let spec_consts = cs::SpecializationConstants { enable: 1, multiple: 1, @@ -72,8 +66,7 @@ fn main() { let data_buffer = { let data_iter = (0 .. 65536u32).map(|n| n); - CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), - data_iter).expect("failed to create buffer") + CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap() }; let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0) @@ -85,13 +78,13 @@ fn main() { .dispatch([1024, 1, 1], pipeline.clone(), set.clone(), ()).unwrap() .build().unwrap(); - let future = now(device.clone()) + let future = sync::now(device.clone()) .then_execute(queue.clone(), command_buffer).unwrap() .then_signal_fence_and_flush().unwrap(); future.wait(None).unwrap(); - let data_buffer_content = data_buffer.read().expect("failed to lock buffer for reading"); + let data_buffer_content = data_buffer.read().unwrap(); for n in 0 .. 65536u32 { assert_eq!(data_buffer_content[n as usize], n * 1 + 1); } diff --git a/examples/src/bin/teapot/main.rs b/examples/src/bin/teapot/main.rs index 9d97ccaa..9e7613be 100644 --- a/examples/src/bin/teapot/main.rs +++ b/examples/src/bin/teapot/main.rs @@ -7,20 +7,18 @@ // notice may not be copied, modified, or distributed except // according to those terms. -extern crate examples; -extern crate cgmath; -extern crate winit; -extern crate time; - #[macro_use] extern crate vulkano; extern crate vulkano_win; - -use vulkano_win::VkSurfaceBuild; +extern crate winit; +extern crate cgmath; +extern crate time; +extern crate examples; use vulkano::buffer::cpu_pool::CpuBufferPool; use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer}; use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState}; +use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; use vulkano::device::{Device, DeviceExtensions}; use vulkano::format::Format; use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, Subpass, RenderPassAbstract}; @@ -28,12 +26,15 @@ use vulkano::image::SwapchainImage; use vulkano::image::attachment::AttachmentImage; use vulkano::instance::Instance; use vulkano::instance::PhysicalDevice; -use vulkano::pipeline::{GraphicsPipeline, GraphicsPipelineAbstract}; use vulkano::pipeline::vertex::TwoBuffersDefinition; use vulkano::pipeline::viewport::Viewport; +use vulkano::pipeline::{GraphicsPipeline, GraphicsPipelineAbstract}; use vulkano::swapchain::{AcquireError, PresentMode, SurfaceTransform, Swapchain, SwapchainCreationError}; use vulkano::swapchain; use vulkano::sync::GpuFuture; +use vulkano::sync; + +use vulkano_win::VkSurfaceBuild; use winit::Window; @@ -41,17 +42,18 @@ use cgmath::{Matrix3, Matrix4, Point3, Vector3, Rad}; use examples::{Vertex, Normal, VERTICES, NORMALS, INDICES}; -use std::sync::Arc; use std::iter; +use std::sync::Arc; +use std::time::Instant; fn main() { // The start of this example is exactly the same as `triangle`. You should read the // `triangle` example if you haven't done so yet. let extensions = vulkano_win::required_extensions(); - let instance = Instance::new(None, &extensions, None).expect("failed to create instance"); + let instance = Instance::new(None, &extensions, None).unwrap(); - let physical = PhysicalDevice::enumerate(&instance).next().expect("no device available"); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); println!("Using device: {} (type: {:?})", physical.name(), physical.ty()); let mut events_loop = winit::EventsLoop::new(); @@ -69,24 +71,24 @@ fn main() { let queue_family = physical.queue_families().find(|&q| q.supports_graphics() && surface.is_supported(q).unwrap_or(false) - ).expect("couldn't find a graphical queue family"); + ).unwrap(); let device_ext = DeviceExtensions { khr_swapchain: true, .. DeviceExtensions::none() }; let (device, mut queues) = Device::new( physical, physical.supported_features(), &device_ext, [(queue_family, 0.5)].iter().cloned() - ).expect("failed to create device"); + ).unwrap(); let queue = queues.next().unwrap(); let (mut swapchain, images) = { - let caps = surface.capabilities(physical).expect("failed to get surface capabilities"); + let caps = surface.capabilities(physical).unwrap(); let usage = caps.supported_usage_flags; let format = caps.supported_formats[0].0; let alpha = caps.supported_composite_alpha.iter().next().unwrap(); Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format, dimensions, 1, - usage, &queue, SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, None).expect("failed to create swapchain") + usage, &queue, SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, None).unwrap() }; let vertices = VERTICES.iter().cloned(); @@ -100,8 +102,8 @@ fn main() { let uniform_buffer = CpuBufferPool::::new(device.clone(), BufferUsage::all()); - let vs = vs::Shader::load(device.clone()).expect("failed to create shader module"); - let fs = fs::Shader::load(device.clone()).expect("failed to create shader module"); + let vs = vs::Shader::load(device.clone()).unwrap(); + let fs = fs::Shader::load(device.clone()).unwrap(); let render_pass = Arc::new( single_pass_renderpass!(device.clone(), @@ -115,7 +117,7 @@ fn main() { depth: { load: Clear, store: DontCare, - format: vulkano::format::Format::D16Unorm, + format: Format::D16Unorm, samples: 1, } }, @@ -129,8 +131,8 @@ fn main() { let (mut pipeline, mut framebuffers) = window_size_dependent_setup(device.clone(), &vs, &fs, &images, render_pass.clone()); let mut recreate_swapchain = false; - let mut previous_frame = Box::new(vulkano::sync::now(device.clone())) as Box; - let rotation_start = std::time::Instant::now(); + let mut previous_frame = Box::new(sync::now(device.clone())) as Box; + let rotation_start = Instant::now(); loop { previous_frame.cleanup_finished(); @@ -178,7 +180,7 @@ fn main() { uniform_buffer.next(uniform_data).unwrap() }; - let set = Arc::new(vulkano::descriptor::descriptor_set::PersistentDescriptorSet::start(pipeline.clone(), 0) + let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0) .add_buffer(uniform_buffer_subbuffer).unwrap() .build().unwrap() ); @@ -198,7 +200,8 @@ fn main() { vec![ [0.0, 0.0, 1.0, 1.0].into(), 1f32.into() - ]).unwrap() + ] + ).unwrap() .draw_indexed( pipeline.clone(), &DynamicState::none(), @@ -216,13 +219,13 @@ fn main() { Ok(future) => { previous_frame = Box::new(future) as Box<_>; } - Err(vulkano::sync::FlushError::OutOfDate) => { + Err(sync::FlushError::OutOfDate) => { recreate_swapchain = true; - previous_frame = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame = Box::new(sync::now(device.clone())) as Box<_>; } Err(e) => { println!("{:?}", e); - previous_frame = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame = Box::new(sync::now(device.clone())) as Box<_>; } } @@ -238,7 +241,7 @@ fn main() { } } -/// This method is called once during initialization then again whenever the window is resized +/// This method is called once during initialization, then again whenever the window is resized fn window_size_dependent_setup( device: Arc, vs: &vs::Shader, diff --git a/examples/src/bin/tessellation.rs b/examples/src/bin/tessellation.rs index 5b1ea6aa..050b8290 100644 --- a/examples/src/bin/tessellation.rs +++ b/examples/src/bin/tessellation.rs @@ -24,22 +24,22 @@ extern crate vulkano_shaders; extern crate winit; extern crate vulkano_win; -use vulkano_win::VkSurfaceBuild; - use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer}; use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState}; -use vulkano::device::Device; +use vulkano::device::{Device, DeviceExtensions}; use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, Subpass, RenderPassAbstract}; use vulkano::image::SwapchainImage; -use vulkano::instance::Instance; +use vulkano::instance::{Instance, PhysicalDevice}; use vulkano::pipeline::GraphicsPipeline; use vulkano::pipeline::viewport::Viewport; -use vulkano::swapchain; use vulkano::swapchain::{AcquireError, PresentMode, SurfaceTransform, Swapchain, SwapchainCreationError}; -use vulkano::sync::now; -use vulkano::sync::GpuFuture; +use vulkano::swapchain; +use vulkano::sync::{GpuFuture, FlushError}; +use vulkano::sync; -use winit::Window; +use vulkano_win::VkSurfaceBuild; + +use winit::{EventsLoop, Window, WindowBuilder, Event, WindowEvent}; use std::sync::Arc; @@ -136,34 +136,26 @@ void main() { fn main() { - let instance = { - let extensions = vulkano_win::required_extensions(); - Instance::new(None, &extensions, None).expect("failed to create Vulkan instance") - }; + let extensions = vulkano_win::required_extensions(); + let instance = Instance::new(None, &extensions, None).unwrap(); - let physical = vulkano::instance::PhysicalDevice::enumerate(&instance) - .next().expect("no device available"); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); println!("Using device: {} (type: {:?})", physical.name(), physical.ty()); - let mut events_loop = winit::EventsLoop::new(); - let surface = winit::WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); + let mut events_loop = EventsLoop::new(); + let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); let window = surface.window(); - let queue = physical.queue_families().find(|&q| { + let queue_family = physical.queue_families().find(|&q| { q.supports_graphics() && surface.is_supported(q).unwrap_or(false) - }).expect("couldn't find a graphical queue family"); - let (device, mut queues) = { - let device_ext = vulkano::device::DeviceExtensions { - khr_swapchain: true, - .. vulkano::device::DeviceExtensions::none() - }; + }).unwrap(); - Device::new(physical, physical.supported_features(), &device_ext, - [(queue, 0.5)].iter().cloned()).expect("failed to create device") - }; + let device_ext = DeviceExtensions { khr_swapchain: true, .. DeviceExtensions::none() }; + let (device, mut queues) = Device::new(physical, physical.supported_features(), &device_ext, + [(queue_family, 0.5)].iter().cloned()).unwrap(); let queue = queues.next().unwrap(); - let mut dimensions = if let Some(dimensions) = window.get_inner_size() { + let initial_dimensions = if let Some(dimensions) = window.get_inner_size() { let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); [dimensions.0, dimensions.1] } else { @@ -171,16 +163,13 @@ fn main() { }; let (mut swapchain, images) = { - let caps = surface.capabilities(physical) - .expect("failed to get surface capabilities"); - + let caps = surface.capabilities(physical).unwrap(); + let usage = caps.supported_usage_flags; let alpha = caps.supported_composite_alpha.iter().next().unwrap(); let format = caps.supported_formats[0].0; - Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format, - dimensions, 1, caps.supported_usage_flags, &queue, - SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, - None).expect("failed to create swapchain") + Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format, initial_dimensions, + 1, usage, &queue, SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, None).unwrap() }; let vertex_buffer = { @@ -198,15 +187,16 @@ fn main() { Vertex { position: [-0.9, 0.9] }, Vertex { position: [-0.7, 0.6] }, Vertex { position: [-0.5, 0.9] }, - ].iter().cloned()).expect("failed to create buffer") + ].iter().cloned()).unwrap() }; - let vs = vs::Shader::load(device.clone()).expect("failed to create shader module"); - let tcs = tcs::Shader::load(device.clone()).expect("failed to create shader module"); - let tes = tes::Shader::load(device.clone()).expect("failed to create shader module"); - let fs = fs::Shader::load(device.clone()).expect("failed to create shader module"); + let vs = vs::Shader::load(device.clone()).unwrap(); + let tcs = tcs::Shader::load(device.clone()).unwrap(); + let tes = tes::Shader::load(device.clone()).unwrap(); + let fs = fs::Shader::load(device.clone()).unwrap(); - let render_pass = Arc::new(single_pass_renderpass!(device.clone(), + let render_pass = Arc::new(single_pass_renderpass!( + device.clone(), attachments: { color: { load: Clear, @@ -239,14 +229,14 @@ fn main() { .unwrap()); let mut recreate_swapchain = false; - let mut previous_frame_end = Box::new(now(device.clone())) as Box; + let mut previous_frame_end = Box::new(sync::now(device.clone())) as Box; let mut dynamic_state = DynamicState { line_width: None, viewports: None, scissors: None }; let mut framebuffers = window_size_dependent_setup(&images, render_pass.clone(), &mut dynamic_state); loop { previous_frame_end.cleanup_finished(); if recreate_swapchain { - dimensions = if let Some(dimensions) = window.get_inner_size() { + let dimensions = if let Some(dimensions) = window.get_inner_size() { let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); [dimensions.0, dimensions.1] } else { @@ -279,9 +269,7 @@ fn main() { let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()).unwrap() .begin_render_pass(framebuffers[image_num].clone(), false, vec![[0.0, 0.0, 0.0, 1.0].into()]) .unwrap() - .draw(pipeline.clone(), - &dynamic_state, - vertex_buffer.clone(), (), ()) + .draw(pipeline.clone(), &dynamic_state, vertex_buffer.clone(), (), ()) .unwrap() .end_render_pass() .unwrap() @@ -296,21 +284,21 @@ fn main() { Ok(future) => { previous_frame_end = Box::new(future) as Box<_>; } - Err(vulkano::sync::FlushError::OutOfDate) => { + Err(FlushError::OutOfDate) => { recreate_swapchain = true; - previous_frame_end = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>; } Err(e) => { println!("{:?}", e); - previous_frame_end = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>; } } let mut done = false; events_loop.poll_events(|ev| { match ev { - winit::Event::WindowEvent { event: winit::WindowEvent::CloseRequested, .. } => done = true, - winit::Event::WindowEvent { event: winit::WindowEvent::Resized(_), .. } => recreate_swapchain = true, + Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => done = true, + Event::WindowEvent { event: WindowEvent::Resized(_), .. } => recreate_swapchain = true, _ => () } }); @@ -318,6 +306,7 @@ fn main() { } } +/// This method is called once during initialization, then again whenever the window is resized fn window_size_dependent_setup( images: &[Arc>], render_pass: Arc, diff --git a/examples/src/bin/triangle.rs b/examples/src/bin/triangle.rs index 7553a223..e11e0372 100644 --- a/examples/src/bin/triangle.rs +++ b/examples/src/bin/triangle.rs @@ -30,23 +30,22 @@ extern crate winit; // the two. extern crate vulkano_win; -use vulkano_win::VkSurfaceBuild; - use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer}; use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState}; -use vulkano::device::Device; +use vulkano::device::{Device, DeviceExtensions}; use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, Subpass, RenderPassAbstract}; use vulkano::image::SwapchainImage; -use vulkano::instance::Instance; -use vulkano::instance::PhysicalDevice; +use vulkano::instance::{Instance, PhysicalDevice}; use vulkano::pipeline::GraphicsPipeline; use vulkano::pipeline::viewport::Viewport; use vulkano::swapchain::{AcquireError, PresentMode, SurfaceTransform, Swapchain, SwapchainCreationError}; use vulkano::swapchain; -use vulkano::sync::GpuFuture; -use vulkano::sync::now; +use vulkano::sync::{GpuFuture, FlushError}; +use vulkano::sync; -use winit::Window; +use vulkano_win::VkSurfaceBuild; + +use winit::{EventsLoop, Window, WindowBuilder, Event, WindowEvent}; use std::sync::Arc; @@ -97,7 +96,7 @@ fn main() { let extensions = vulkano_win::required_extensions(); // Now creating the instance. - Instance::new(None, &extensions, None).expect("failed to create Vulkan instance") + Instance::new(None, &extensions, None).unwrap() }; // We then choose which physical device to use. @@ -114,7 +113,7 @@ fn main() { // // For the sake of the example we are just going to use the first device, which should work // most of the time. - let physical = PhysicalDevice::enumerate(&instance).next().expect("no device available"); + let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); // Some little debug infos. println!("Using device: {} (type: {:?})", physical.name(), physical.ty()); @@ -129,8 +128,8 @@ fn main() { // // This returns a `vulkano::swapchain::Surface` object that contains both a cross-platform winit // window and a cross-platform Vulkan surface that represents the surface of the window. - let mut events_loop = winit::EventsLoop::new(); - let surface = winit::WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); + let mut events_loop = EventsLoop::new(); + let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); let window = surface.window(); // The next step is to choose which GPU queue will execute our draw commands. @@ -146,7 +145,7 @@ fn main() { let queue_family = physical.queue_families().find(|&q| { // We take the first queue that supports drawing to our window. q.supports_graphics() && surface.is_supported(q).unwrap_or(false) - }).expect("couldn't find a graphical queue family"); + }).unwrap(); // Now initializing the device. This is probably the most important object of Vulkan. // @@ -167,43 +166,24 @@ fn main() { // much it should prioritize queues between one another. // // The list of created queues is returned by the function alongside with the device. - let (device, mut queues) = { - let device_ext = vulkano::device::DeviceExtensions { - khr_swapchain: true, - .. vulkano::device::DeviceExtensions::none() - }; - - Device::new(physical, physical.supported_features(), &device_ext, - [(queue_family, 0.5)].iter().cloned()).expect("failed to create device") - }; + let device_ext = DeviceExtensions { khr_swapchain: true, .. DeviceExtensions::none() }; + let (device, mut queues) = Device::new(physical, physical.supported_features(), &device_ext, + [(queue_family, 0.5)].iter().cloned()).unwrap(); // Since we can request multiple queues, the `queues` variable is in fact an iterator. In this // example we use only one queue, so we just retrieve the first and only element of the // iterator and throw it away. let queue = queues.next().unwrap(); - // The dimensions of the window, only used to initially setup the swapchain. - let initial_dimensions = if let Some(dimensions) = window.get_inner_size() { - // convert to physical pixels - let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); - [dimensions.0, dimensions.1] - } else { - // The window no longer exists so exit the application. - return; - }; - // Before we can draw on the surface, we have to create what is called a swapchain. Creating // a swapchain allocates the color buffers that will contain the image that will ultimately // be visible on the screen. These images are returned alongside with the swapchain. let (mut swapchain, images) = { // Querying the capabilities of the surface. When we create the swapchain we can only // pass values that are allowed by the capabilities. - let caps = surface.capabilities(physical) - .expect("failed to get surface capabilities"); + let caps = surface.capabilities(physical).unwrap(); - // We choose the dimensions of the swapchain to match the current extent of the surface. - // If `caps.current_extent` is `None`, this means that the window size will be determined - // by the dimensions of the swapchain, in which case we just use the width and height defined above. + let usage = caps.supported_usage_flags; // The alpha mode indicates how the alpha value of the final image will behave. For example // you can choose whether the window will be opaque or transparent. @@ -212,11 +192,30 @@ fn main() { // Choosing the internal format that the images will have. let format = caps.supported_formats[0].0; + // The dimensions of the window, only used to initially setup the swapchain. + // NOTE: + // On some drivers the swapchain dimensions are specified by `caps.current_extent` and the + // swapchain size must use these dimensions. + // These dimensions are always the same as the window dimensions + // + // However other drivers dont specify a value i.e. `caps.current_extent` is `None` + // These drivers will allow anything but the only sensible value is the window dimensions. + // + // Because for both of these cases, the swapchain needs to be the window dimensions, we just use that. + let initial_dimensions = if let Some(dimensions) = window.get_inner_size() { + // convert to physical pixels + let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); + [dimensions.0, dimensions.1] + } else { + // The window no longer exists so exit the application. + return; + }; + // Please take a look at the docs for the meaning of the parameters we didn't mention. Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format, - initial_dimensions, 1, caps.supported_usage_flags, &queue, - SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, - None).expect("failed to create swapchain") + initial_dimensions, 1, usage, &queue, SurfaceTransform::Identity, alpha, + PresentMode::Fifo, true, None).unwrap() + }; // We now create a buffer that will store the shape of our triangle. @@ -229,11 +228,11 @@ fn main() { Vertex { position: [-0.5, -0.25] }, Vertex { position: [0.0, 0.5] }, Vertex { position: [0.25, -0.1] } - ].iter().cloned()).expect("failed to create buffer") + ].iter().cloned()).unwrap() }; - let vs = vs::Shader::load(device.clone()).expect("failed to create shader module"); - let fs = fs::Shader::load(device.clone()).expect("failed to create shader module"); + let vs = vs::Shader::load(device.clone()).unwrap(); + let fs = fs::Shader::load(device.clone()).unwrap(); // At this point, OpenGL initialization would be finished. However in Vulkan it is not. OpenGL // implicitly does a lot of computation whenever you draw. In Vulkan, you have to do all this @@ -242,7 +241,8 @@ fn main() { // The next step is to create a *render pass*, which is an object that describes where the // output of the graphics pipeline will go. It describes the layout of the images // where the colors, depth and/or stencil information will be written. - let render_pass = Arc::new(single_pass_renderpass!(device.clone(), + let render_pass = Arc::new(single_pass_renderpass!( + device.clone(), attachments: { // `color` is a custom name we give to the first and only attachment. color: { @@ -254,9 +254,8 @@ fn main() { store: Store, // `format: ` indicates the type of the format of the image. This has to // be one of the types of the `vulkano::format` module (or alternatively one - // of your structs that implements the `FormatDesc` trait). Here we use the - // generic `vulkano::format::Format` enum because we don't know the format in - // advance. + // of your structs that implements the `FormatDesc` trait). Here we use the + // same format as the swapchain. format: swapchain.format(), // TODO: samples: 1, @@ -324,7 +323,7 @@ fn main() { // // Destroying the `GpuFuture` blocks until the GPU is finished executing it. In order to avoid // that, we store the submission of the previous frame here. - let mut previous_frame_end = Box::new(now(device.clone())) as Box; + let mut previous_frame_end = Box::new(sync::now(device.clone())) as Box; loop { // It is important to call this function from time to time, otherwise resources will keep @@ -336,7 +335,7 @@ fn main() { // Whenever the window resizes we need to recreate everything dependent on the window size. // In this example that includes the swapchain, the framebuffers and the dynamic state viewport. if recreate_swapchain { - // Get the new dimensions for the viewport/framebuffers. + // Get the new dimensions of the window. let dimensions = if let Some(dimensions) = window.get_inner_size() { let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into(); [dimensions.0, dimensions.1] @@ -376,6 +375,9 @@ fn main() { Err(err) => panic!("{:?}", err) }; + // Specify the color to clear the framebuffer with i.e. blue + let clear_values = vec!([0.0, 0.0, 1.0, 1.0].into()); + // In order to draw, we have to build a *command buffer*. The command buffer object holds // the list of commands that are going to be executed. // @@ -393,17 +395,14 @@ fn main() { // The third parameter builds the list of values to clear the attachments with. The API // is similar to the list of attachments when building the framebuffers, except that // only the attachments that use `load: Clear` appear in the list. - .begin_render_pass(framebuffers[image_num].clone(), false, - vec![[0.0, 0.0, 1.0, 1.0].into()]) + .begin_render_pass(framebuffers[image_num].clone(), false, clear_values) .unwrap() // We are now inside the first subpass of the render pass. We add a draw command. // // The last two parameters contain the list of resources to pass to the shaders. // Since we used an `EmptyPipeline` object, the objects have to be `()`. - .draw(pipeline.clone(), - &dynamic_state, - vertex_buffer.clone(), (), ()) + .draw(pipeline.clone(), &dynamic_state, vertex_buffer.clone(), (), ()) .unwrap() // We leave the render pass by calling `draw_end`. Note that if we had multiple @@ -431,13 +430,13 @@ fn main() { Ok(future) => { previous_frame_end = Box::new(future) as Box<_>; } - Err(vulkano::sync::FlushError::OutOfDate) => { + Err(FlushError::OutOfDate) => { recreate_swapchain = true; - previous_frame_end = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>; } Err(e) => { println!("{:?}", e); - previous_frame_end = Box::new(vulkano::sync::now(device.clone())) as Box<_>; + previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>; } } @@ -454,8 +453,8 @@ fn main() { let mut done = false; events_loop.poll_events(|ev| { match ev { - winit::Event::WindowEvent { event: winit::WindowEvent::CloseRequested, .. } => done = true, - winit::Event::WindowEvent { event: winit::WindowEvent::Resized(_), .. } => recreate_swapchain = true, + Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => done = true, + Event::WindowEvent { event: WindowEvent::Resized(_), .. } => recreate_swapchain = true, _ => () } }); @@ -463,7 +462,7 @@ fn main() { } } -/// This method is called once during initialization then again whenever the window is resized +/// This method is called once during initialization, then again whenever the window is resized fn window_size_dependent_setup( images: &[Arc>], render_pass: Arc, diff --git a/vulkano-shaders/src/lib.rs b/vulkano-shaders/src/lib.rs index 96ba9aa9..3c827593 100644 --- a/vulkano-shaders/src/lib.rs +++ b/vulkano-shaders/src/lib.rs @@ -107,10 +107,6 @@ //! //! The options available are in the form of the following attributes: //! -//! ## `mod_name: ...` -//! -//! Specifies the identifier for the module that the generated code goes in. -//! //! ## `ty: "..."` //! //! This defines what shader type the given GLSL source will be compiled into.