alex/ash
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update examples to winit 0.9

Browse source
This commit is contained in:
Maik Klein 2017-12-12 14:25:10 +01:00
parent 65e1a7689d
commit c0b6078028
2 changed files with 239 additions and 175 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
examples/Cargo.toml
View file

@ -4,7 +4,7 @@ version = "0.1.0"
authors = ["maik klein <maikklein@googlemail.com>"]
[dependencies]
winit = "0.5.6"
winit = "0.9.0"
image = "0.10.4"
ash = { path = "../ash" }

412
examples/src/lib.rs
View file

@ -1,19 +1,20 @@
#![allow(dead_code)]
#[macro_use]
extern crate ash;
extern crate winit;
#[cfg(windows)]
extern crate user32;
#[cfg(windows)]
extern crate winapi;
extern crate winit;
use ash::vk;
use std::default::Default;
use ash::Entry;
use ash::Instance;
use ash::Device;
pub use ash::version::{V1_0, InstanceV1_0, DeviceV1_0, EntryV1_0};
use ash::extensions::{Swapchain, XlibSurface, Surface, DebugReport, Win32Surface};
pub use ash::version::{DeviceV1_0, EntryV1_0, InstanceV1_0, V1_0};
use ash::extensions::{DebugReport, Surface, Swapchain, Win32Surface, XlibSurface};
use std::cell::RefCell;
use std::ptr;
use std::ffi::{CStr, CString};
use std::ops::Drop;
@ -32,16 +33,21 @@ macro_rules! offset_of{
}
}
pub fn record_submit_commandbuffer<D: DeviceV1_0, F: FnOnce(&D, vk::CommandBuffer)>(device: &D,
command_buffer: vk::CommandBuffer,
submit_queue: vk::Queue,
wait_mask: &[vk::PipelineStageFlags],
wait_semaphores: &[vk::Semaphore],
signal_semaphores: &[vk::Semaphore],
f: F) {
pub fn record_submit_commandbuffer<D: DeviceV1_0, F: FnOnce(&D, vk::CommandBuffer)>(
device: &D,
command_buffer: vk::CommandBuffer,
submit_queue: vk::Queue,
wait_mask: &[vk::PipelineStageFlags],
wait_semaphores: &[vk::Semaphore],
signal_semaphores: &[vk::Semaphore],
f: F,
) {
unsafe {
device.reset_command_buffer(command_buffer,
vk::COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)
device
.reset_command_buffer(
command_buffer,
vk::COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT,
)
.expect("Reset command buffer failed.");
let command_buffer_begin_info = vk::CommandBufferBeginInfo {
s_type: vk::StructureType::CommandBufferBeginInfo,
@ -49,16 +55,20 @@ pub fn record_submit_commandbuffer<D: DeviceV1_0, F: FnOnce(&D, vk::CommandBuffe
p_inheritance_info: ptr::null(),
flags: vk::COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
};
device.begin_command_buffer(command_buffer, &command_buffer_begin_info)
device
.begin_command_buffer(command_buffer, &command_buffer_begin_info)
.expect("Begin commandbuffer");
f(device, command_buffer);
device.end_command_buffer(command_buffer).expect("End commandbuffer");
device
.end_command_buffer(command_buffer)
.expect("End commandbuffer");
let fence_create_info = vk::FenceCreateInfo {
s_type: vk::StructureType::FenceCreateInfo,
p_next: ptr::null(),
flags: vk::FenceCreateFlags::empty(),
};
let submit_fence = device.create_fence(&fence_create_info, None)
let submit_fence = device
.create_fence(&fence_create_info, None)
.expect("Create fence failed.");
let submit_info = vk::SubmitInfo {
s_type: vk::StructureType::SubmitInfo,
@ -71,19 +81,22 @@ pub fn record_submit_commandbuffer<D: DeviceV1_0, F: FnOnce(&D, vk::CommandBuffe
signal_semaphore_count: signal_semaphores.len() as u32,
p_signal_semaphores: signal_semaphores.as_ptr(),
};
device.queue_submit(submit_queue, &[submit_info], submit_fence)
device
.queue_submit(submit_queue, &[submit_info], submit_fence)
.expect("queue submit failed.");
device.wait_for_fences(&[submit_fence], true, std::u64::MAX)
device
.wait_for_fences(&[submit_fence], true, std::u64::MAX)
.expect("Wait for fence failed.");
device.destroy_fence(submit_fence, None);
}
}
#[cfg(all(unix, not(target_os = "android")))]
unsafe fn create_surface<E: EntryV1_0, I: InstanceV1_0>(entry: &E,
instance: &I,
window: &winit::Window)
-> Result<vk::SurfaceKHR, vk::Result> {
unsafe fn create_surface<E: EntryV1_0, I: InstanceV1_0>(
entry: &E,
instance: &I,
window: &winit::Window,
) -> Result<vk::SurfaceKHR, vk::Result> {
use winit::os::unix::WindowExt;
let x11_display = window.get_xlib_display().unwrap();
let x11_window = window.get_xlib_window().unwrap();
@ -94,16 +107,17 @@ unsafe fn create_surface<E: EntryV1_0, I: InstanceV1_0>(entry: &E,
window: x11_window as vk::Window,
dpy: x11_display as *mut vk::Display,
};
let xlib_surface_loader = XlibSurface::new(entry, instance)
.expect("Unable to load xlib surface");
let xlib_surface_loader =
XlibSurface::new(entry, instance).expect("Unable to load xlib surface");
xlib_surface_loader.create_xlib_surface_khr(&x11_create_info, None)
}
#[cfg(windows)]
unsafe fn create_surface<E: EntryV1_0, I: InstanceV1_0>(entry: &E,
instance: &I,
window: &winit::Window)
-> Result<vk::SurfaceKHR, vk::Result> {
unsafe fn create_surface<E: EntryV1_0, I: InstanceV1_0>(
entry: &E,
instance: &I,
window: &winit::Window,
) -> Result<vk::SurfaceKHR, vk::Result> {
use winit::os::windows::WindowExt;
let hwnd = window.get_hwnd() as *mut winapi::windef::HWND__;
let hinstance = unsafe { user32::GetWindow(hwnd, 0) as *const vk::c_void };
@ -114,61 +128,69 @@ unsafe fn create_surface<E: EntryV1_0, I: InstanceV1_0>(entry: &E,
hinstance: hinstance,
hwnd: hwnd as *const vk::c_void,
};
let win32_surface_loader = Win32Surface::new(entry, instance)
.expect("Unable to load win32 surface");
let win32_surface_loader =
Win32Surface::new(entry, instance).expect("Unable to load win32 surface");
win32_surface_loader.create_win32_surface_khr(&win32_create_info, None)
}
#[cfg(all(unix, not(target_os = "android")))]
fn extension_names() -> Vec<*const i8> {
vec![Surface::name().as_ptr(), XlibSurface::name().as_ptr(), DebugReport::name().as_ptr()]
vec![
Surface::name().as_ptr(),
XlibSurface::name().as_ptr(),
DebugReport::name().as_ptr(),
]
}
#[cfg(all(windows))]
fn extension_names() -> Vec<*const i8> {
vec![Surface::name().as_ptr(), Win32Surface::name().as_ptr(), DebugReport::name().as_ptr()]
vec![
Surface::name().as_ptr(),
Win32Surface::name().as_ptr(),
DebugReport::name().as_ptr(),
]
}
unsafe extern "system" fn vulkan_debug_callback(_: vk::DebugReportFlagsEXT,
_: vk::DebugReportObjectTypeEXT,
_: vk::uint64_t,
_: vk::size_t,
_: vk::int32_t,
_: *const vk::c_char,
p_message: *const vk::c_char,
_: *mut vk::c_void)
-> u32 {
unsafe extern "system" fn vulkan_debug_callback(
_: vk::DebugReportFlagsEXT,
_: vk::DebugReportObjectTypeEXT,
_: vk::uint64_t,
_: vk::size_t,
_: vk::int32_t,
_: *const vk::c_char,
p_message: *const vk::c_char,
_: *mut vk::c_void,
) -> u32 {
println!("{:?}", CStr::from_ptr(p_message));
1
}
pub fn find_memorytype_index(memory_req: &vk::MemoryRequirements,
memory_prop: &vk::PhysicalDeviceMemoryProperties,
flags: vk::MemoryPropertyFlags)
-> Option<u32> {
pub fn find_memorytype_index(
memory_req: &vk::MemoryRequirements,
memory_prop: &vk::PhysicalDeviceMemoryProperties,
flags: vk::MemoryPropertyFlags,
) -> Option<u32> {
// Try to find an exactly matching memory flag
let best_suitable_index =
find_memorytype_index_f(memory_req,
memory_prop,
flags,
|property_flags, flags| property_flags == flags);
find_memorytype_index_f(memory_req, memory_prop, flags, |property_flags, flags| {
property_flags == flags
});
if best_suitable_index.is_some() {
return best_suitable_index;
}
// Otherwise find a memory flag that works
find_memorytype_index_f(memory_req,
memory_prop,
flags,
|property_flags, flags| property_flags & flags == flags)
find_memorytype_index_f(memory_req, memory_prop, flags, |property_flags, flags| {
property_flags & flags == flags
})
}
pub fn find_memorytype_index_f<F: Fn(vk::MemoryPropertyFlags, vk::MemoryPropertyFlags) -> bool>
(memory_req: &vk::MemoryRequirements,
memory_prop: &vk::PhysicalDeviceMemoryProperties,
flags: vk::MemoryPropertyFlags,
f: F)
-> Option<u32> {
pub fn find_memorytype_index_f<F: Fn(vk::MemoryPropertyFlags, vk::MemoryPropertyFlags) -> bool>(
memory_req: &vk::MemoryRequirements,
memory_prop: &vk::PhysicalDeviceMemoryProperties,
flags: vk::MemoryPropertyFlags,
f: F,
) -> Option<u32> {
let mut memory_type_bits = memory_req.memory_type_bits;
for (index, ref memory_type) in memory_prop.memory_types.iter().enumerate() {
if memory_type_bits & 1 == 1 {
@ -193,6 +215,7 @@ pub struct ExampleBase {
pub swapchain_loader: Swapchain,
pub debug_report_loader: DebugReport,
pub window: winit::Window,
pub events_loop: RefCell<winit::EventsLoop>,
pub debug_call_back: vk::DebugReportCallbackEXT,
pub pdevice: vk::PhysicalDevice,
@ -222,31 +245,41 @@ pub struct ExampleBase {
impl ExampleBase {
pub fn render_loop<F: Fn()>(&self, f: F) {
'render: loop {
for event in self.window.poll_events() {
match event {
winit::Event::KeyboardInput(_, _, Some(winit::VirtualKeyCode::Escape)) |
winit::Event::Closed => break 'render,
_ => (),
}
}
use winit::*;
self.events_loop.borrow_mut().run_forever(|event| {
f();
}
match event {
Event::WindowEvent { event, .. } => match event {
WindowEvent::KeyboardInput { input, .. } => {
if let Some(VirtualKeyCode::Escape) = input.virtual_keycode {
ControlFlow::Break
} else {
ControlFlow::Continue
}
}
WindowEvent::Closed => winit::ControlFlow::Break,
_ => ControlFlow::Continue,
},
_ => ControlFlow::Continue,
}
});
}
pub fn new(window_width: u32, window_height: u32) -> Self {
unsafe {
let events_loop = winit::EventsLoop::new();
let window = winit::WindowBuilder::new()
.with_title("Ash - Example")
.with_dimensions(window_width, window_height)
.with_window_resize_callback(resize_callback)
.build()
//.with_window_resize_callback(resize_callback)
.build(&events_loop)
.unwrap();
let entry = Entry::new().unwrap();
let app_name = CString::new("VulkanTriangle").unwrap();
let raw_name = app_name.as_ptr();
let layer_names = [CString::new("VK_LAYER_LUNARG_standard_validation").unwrap()];
let layers_names_raw: Vec<*const i8> = layer_names.iter()
let layers_names_raw: Vec<*const i8> = layer_names
.iter()
.map(|raw_name| raw_name.as_ptr())
.collect();
let extension_names_raw = extension_names();
@ -269,36 +302,43 @@ impl ExampleBase {
pp_enabled_extension_names: extension_names_raw.as_ptr(),
enabled_extension_count: extension_names_raw.len() as u32,
};
let instance: Instance<V1_0> = entry.create_instance(&create_info, None)
let instance: Instance<V1_0> = entry
.create_instance(&create_info, None)
.expect("Instance creation error");
let debug_info = vk::DebugReportCallbackCreateInfoEXT {
s_type: vk::StructureType::DebugReportCallbackCreateInfoExt,
p_next: ptr::null(),
flags: vk::DEBUG_REPORT_ERROR_BIT_EXT | vk::DEBUG_REPORT_WARNING_BIT_EXT |
vk::DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
flags: vk::DEBUG_REPORT_ERROR_BIT_EXT | vk::DEBUG_REPORT_WARNING_BIT_EXT
| vk::DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
pfn_callback: vulkan_debug_callback,
p_user_data: ptr::null_mut(),
};
let debug_report_loader = DebugReport::new(&entry, &instance)
.expect("Unable to load debug report");
let debug_call_back =
debug_report_loader.create_debug_report_callback_ext(&debug_info, None)
.unwrap();
let debug_report_loader =
DebugReport::new(&entry, &instance).expect("Unable to load debug report");
let debug_call_back = debug_report_loader
.create_debug_report_callback_ext(&debug_info, None)
.unwrap();
let surface = create_surface(&entry, &instance, &window).unwrap();
let pdevices = instance.enumerate_physical_devices().expect("Physical device error");
let surface_loader = Surface::new(&entry, &instance)
.expect("Unable to load the Surface extension");
let (pdevice, queue_family_index) = pdevices.iter()
let pdevices = instance
.enumerate_physical_devices()
.expect("Physical device error");
let surface_loader =
Surface::new(&entry, &instance).expect("Unable to load the Surface extension");
let (pdevice, queue_family_index) = pdevices
.iter()
.map(|pdevice| {
instance.get_physical_device_queue_family_properties(*pdevice)
instance
.get_physical_device_queue_family_properties(*pdevice)
.iter()
.enumerate()
.filter_map(|(index, ref info)| {
let supports_graphic_and_surface =
info.queue_flags.subset(vk::QUEUE_GRAPHICS_BIT) &&
surface_loader.get_physical_device_surface_support_khr(*pdevice,
index as u32,
surface);
let supports_graphic_and_surface = info.queue_flags
.subset(vk::QUEUE_GRAPHICS_BIT)
&& surface_loader.get_physical_device_surface_support_khr(
*pdevice,
index as u32,
surface,
);
match supports_graphic_and_surface {
true => Some((*pdevice, index)),
_ => None,
@ -311,8 +351,10 @@ impl ExampleBase {
.expect("Couldn't find suitable device.");
let queue_family_index = queue_family_index as u32;
let device_extension_names_raw = [Swapchain::name().as_ptr()];
let features =
vk::PhysicalDeviceFeatures { shader_clip_distance: 1, ..Default::default() };
let features = vk::PhysicalDeviceFeatures {
shader_clip_distance: 1,
..Default::default()
};
let priorities = [1.0];
let queue_info = vk::DeviceQueueCreateInfo {
s_type: vk::StructureType::DeviceQueueCreateInfo,
@ -334,58 +376,59 @@ impl ExampleBase {
pp_enabled_extension_names: device_extension_names_raw.as_ptr(),
p_enabled_features: &features,
};
let device: Device<V1_0> = instance.create_device(pdevice, &device_create_info, None)
let device: Device<V1_0> = instance
.create_device(pdevice, &device_create_info, None)
.unwrap();
let present_queue = device.get_device_queue(queue_family_index as u32, 0);
let surface_formats =
surface_loader.get_physical_device_surface_formats_khr(pdevice, surface)
.unwrap();
let surface_format = surface_formats.iter()
.map(|sfmt| {
match sfmt.format {
vk::Format::Undefined => {
vk::SurfaceFormatKHR {
format: vk::Format::B8g8r8Unorm,
color_space: sfmt.color_space,
}
}
_ => sfmt.clone(),
}
let surface_formats = surface_loader
.get_physical_device_surface_formats_khr(pdevice, surface)
.unwrap();
let surface_format = surface_formats
.iter()
.map(|sfmt| match sfmt.format {
vk::Format::Undefined => vk::SurfaceFormatKHR {
format: vk::Format::B8g8r8Unorm,
color_space: sfmt.color_space,
},
_ => sfmt.clone(),
})
.nth(0)
.expect("Unable to find suitable surface format.");
let surface_capabilities =
surface_loader.get_physical_device_surface_capabilities_khr(pdevice, surface)
.unwrap();
let surface_capabilities = surface_loader
.get_physical_device_surface_capabilities_khr(pdevice, surface)
.unwrap();
let mut desired_image_count = surface_capabilities.min_image_count + 1;
if surface_capabilities.max_image_count > 0 && desired_image_count > surface_capabilities.max_image_count{
if surface_capabilities.max_image_count > 0
&& desired_image_count > surface_capabilities.max_image_count
{
desired_image_count = surface_capabilities.max_image_count;
}
let surface_resolution = match surface_capabilities.current_extent.width {
std::u32::MAX => {
vk::Extent2D {
width: window_width,
height: window_height,
}
}
std::u32::MAX => vk::Extent2D {
width: window_width,
height: window_height,
},
_ => surface_capabilities.current_extent,
};
let pre_transform = if surface_capabilities.supported_transforms
.subset(vk::SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
let pre_transform = if surface_capabilities
.supported_transforms
.subset(vk::SURFACE_TRANSFORM_IDENTITY_BIT_KHR)
{
vk::SURFACE_TRANSFORM_IDENTITY_BIT_KHR
} else {
surface_capabilities.current_transform
};
let present_modes =
surface_loader.get_physical_device_surface_present_modes_khr(pdevice, surface)
.unwrap();
let present_mode = present_modes.iter()
let present_modes = surface_loader
.get_physical_device_surface_present_modes_khr(pdevice, surface)
.unwrap();
let present_mode = present_modes
.iter()
.cloned()
.find(|&mode| mode == vk::PresentModeKHR::Mailbox)
.unwrap_or(vk::PresentModeKHR::Fifo);
let swapchain_loader = Swapchain::new(&instance, &device)
.expect("Unable to load swapchain");
let swapchain_loader =
Swapchain::new(&instance, &device).expect("Unable to load swapchain");
let swapchain_create_info = vk::SwapchainCreateInfoKHR {
s_type: vk::StructureType::SwapchainCreateInfoKhr,
p_next: ptr::null(),
@ -406,7 +449,8 @@ impl ExampleBase {
p_queue_family_indices: ptr::null(),
queue_family_index_count: 0,
};
let swapchain = swapchain_loader.create_swapchain_khr(&swapchain_create_info, None)
let swapchain = swapchain_loader
.create_swapchain_khr(&swapchain_create_info, None)
.unwrap();
let pool_create_info = vk::CommandPoolCreateInfo {
s_type: vk::StructureType::CommandPoolCreateInfo,
@ -422,13 +466,17 @@ impl ExampleBase {
command_pool: pool,
level: vk::CommandBufferLevel::Primary,
};
let command_buffers = device.allocate_command_buffers(&command_buffer_allocate_info)
let command_buffers = device
.allocate_command_buffers(&command_buffer_allocate_info)
.unwrap();
let setup_command_buffer = command_buffers[0];
let draw_command_buffer = command_buffers[1];
let present_images = swapchain_loader.get_swapchain_images_khr(swapchain).unwrap();
let present_image_views: Vec<vk::ImageView> = present_images.iter()
let present_images = swapchain_loader
.get_swapchain_images_khr(swapchain)
.unwrap();
let present_image_views: Vec<vk::ImageView> = present_images
.iter()
.map(|&image| {
let create_view_info = vk::ImageViewCreateInfo {
s_type: vk::StructureType::ImageViewCreateInfo,
@ -479,10 +527,11 @@ impl ExampleBase {
let depth_image = device.create_image(&depth_image_create_info, None).unwrap();
let depth_image_memory_req = device.get_image_memory_requirements(depth_image);
let depth_image_memory_index =
find_memorytype_index(&depth_image_memory_req,
&device_memory_properties,
vk::MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
.expect("Unable to find suitable memory index for depth image.");
find_memorytype_index(
&depth_image_memory_req,
&device_memory_properties,
vk::MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
).expect("Unable to find suitable memory index for depth image.");
let depth_image_allocate_info = vk::MemoryAllocateInfo {
s_type: vk::StructureType::MemoryAllocateInfo,
@ -490,44 +539,50 @@ impl ExampleBase {
allocation_size: depth_image_memory_req.size,
memory_type_index: depth_image_memory_index,
};
let depth_image_memory = device.allocate_memory(&depth_image_allocate_info, None)
let depth_image_memory = device
.allocate_memory(&depth_image_allocate_info, None)
.unwrap();
device.bind_image_memory(depth_image, depth_image_memory, 0)
device
.bind_image_memory(depth_image, depth_image_memory, 0)
.expect("Unable to bind depth image memory");
record_submit_commandbuffer(&device,
setup_command_buffer,
present_queue,
&[vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT],
&[],
&[],
|device, setup_command_buffer| {
let layout_transition_barrier = vk::ImageMemoryBarrier {
s_type: vk::StructureType::ImageMemoryBarrier,
p_next: ptr::null(),
src_access_mask: Default::default(),
dst_access_mask: vk::ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
vk::ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
old_layout: vk::ImageLayout::Undefined,
new_layout: vk::ImageLayout::DepthStencilAttachmentOptimal,
src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
image: depth_image,
subresource_range: vk::ImageSubresourceRange {
aspect_mask: vk::IMAGE_ASPECT_DEPTH_BIT,
base_mip_level: 0,
level_count: 1,
base_array_layer: 0,
layer_count: 1,
},
};
device.cmd_pipeline_barrier(setup_command_buffer,
vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
vk::PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
vk::DependencyFlags::empty(),
&[],
&[],
&[layout_transition_barrier]);
});
record_submit_commandbuffer(
&device,
setup_command_buffer,
present_queue,
&[vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT],
&[],
&[],
|device, setup_command_buffer| {
let layout_transition_barrier = vk::ImageMemoryBarrier {
s_type: vk::StructureType::ImageMemoryBarrier,
p_next: ptr::null(),
src_access_mask: Default::default(),
dst_access_mask: vk::ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT
| vk::ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
old_layout: vk::ImageLayout::Undefined,
new_layout: vk::ImageLayout::DepthStencilAttachmentOptimal,
src_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
dst_queue_family_index: vk::VK_QUEUE_FAMILY_IGNORED,
image: depth_image,
subresource_range: vk::ImageSubresourceRange {
aspect_mask: vk::IMAGE_ASPECT_DEPTH_BIT,
base_mip_level: 0,
level_count: 1,
base_array_layer: 0,
layer_count: 1,
},
};
device.cmd_pipeline_barrier(
setup_command_buffer,
vk::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
vk::PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
vk::DependencyFlags::empty(),
&[],
&[],
&[layout_transition_barrier],
);
},
);
let depth_image_view_info = vk::ImageViewCreateInfo {
s_type: vk::StructureType::ImageViewCreateInfo,
p_next: ptr::null(),
@ -549,17 +604,22 @@ impl ExampleBase {
},
image: depth_image,
};
let depth_image_view = device.create_image_view(&depth_image_view_info, None).unwrap();
let depth_image_view = device
.create_image_view(&depth_image_view_info, None)
.unwrap();
let semaphore_create_info = vk::SemaphoreCreateInfo {
s_type: vk::StructureType::SemaphoreCreateInfo,
p_next: ptr::null(),
flags: Default::default(),
};
let present_complete_semaphore = device.create_semaphore(&semaphore_create_info, None)
let present_complete_semaphore = device
.create_semaphore(&semaphore_create_info, None)
.unwrap();
let rendering_complete_semaphore = device.create_semaphore(&semaphore_create_info, None)
let rendering_complete_semaphore = device
.create_semaphore(&semaphore_create_info, None)
.unwrap();
ExampleBase {
events_loop: RefCell::new(events_loop),
entry: entry,
instance: instance,
device: device,
@ -595,8 +655,10 @@ impl Drop for ExampleBase {
fn drop(&mut self) {
unsafe {
self.device.device_wait_idle().unwrap();
self.device.destroy_semaphore(self.present_complete_semaphore, None);
self.device.destroy_semaphore(self.rendering_complete_semaphore, None);
self.device
.destroy_semaphore(self.present_complete_semaphore, None);
self.device
.destroy_semaphore(self.rendering_complete_semaphore, None);
self.device.free_memory(self.depth_image_memory, None);
self.device.destroy_image_view(self.depth_image_view, None);
self.device.destroy_image(self.depth_image, None);
@ -604,10 +666,12 @@ impl Drop for ExampleBase {
self.device.destroy_image_view(image_view, None);
}
self.device.destroy_command_pool(self.pool, None);
self.swapchain_loader.destroy_swapchain_khr(self.swapchain, None);
self.swapchain_loader
.destroy_swapchain_khr(self.swapchain, None);
self.device.destroy_device(None);
self.surface_loader.destroy_surface_khr(self.surface, None);
self.debug_report_loader.destroy_debug_report_callback_ext(self.debug_call_back, None);
self.debug_report_loader
.destroy_debug_report_callback_ext(self.debug_call_back, None);
self.instance.destroy_instance(None);
}
}