Upgrade to winit 0.27, raw-window-handle 0.5, ash-window 0.12 (#142)

* Upgrade to `winit 0.27`, `raw-window-handle 0.5`, `ash-window 0.12`

* vulkan-visualization: Replace `imgui-winit-support` with manual `handle_imgui_event()`

We already use our own implementation in `d3d12`, and `imgui` is still
stuck on `winit 0.26` while a release that fixes this (and more!) is
constantly and consistently being delayed.

* Run `cargo clippy --fix`

Author: MarijnS95

Cargo.toml

@@ -47,10 +47,9 @@ optional = true
 [dev-dependencies]
 # Enable the "loaded" feature to be able to access the Vulkan entrypoint.
 ash = { version = "0.37", default-features = false, features = ["debug", "loaded"] }
-ash-window = "0.10.0"
-raw-window-handle = "0.4"
-winit = "0.26"
-imgui-winit-support = { version = "0.8", default-features = false, features = ["winit-26"] }
+ash-window = "0.12"
+raw-window-handle = "0.5"
+winit = { version = "0.27", features = ["x11", "wayland"] }
 
 [target.'cfg(windows)'.dev-dependencies]
 winapi = { version = "0.3.9", features = ["d3d12", "d3d12sdklayers", "dxgi1_6", "winerror", "impl-default", "impl-debug", "winuser", "windowsx", "libloaderapi"] }

examples/vulkan-visualization/imgui_renderer.rs

@@ -832,3 +832,117 @@ impl ImGuiRenderer {
         }
     }
 }
+
+pub(crate) fn handle_imgui_event(
+    io: &mut imgui::Io,
+    window: &winit::window::Window,
+    event: &winit::event::Event<'_, ()>,
+) -> bool {
+    use winit::event::{
+        DeviceEvent, ElementState, Event, KeyboardInput, MouseButton, MouseScrollDelta, TouchPhase,
+        VirtualKeyCode, WindowEvent,
+    };
+
+    match event {
+        Event::WindowEvent { event, window_id } if *window_id == window.id() => match *event {
+            WindowEvent::Resized(physical_size) => {
+                io.display_size = [physical_size.width as f32, physical_size.height as f32];
+                false
+            }
+            WindowEvent::KeyboardInput {
+                input:
+                    KeyboardInput {
+                        virtual_keycode: Some(key),
+                        state,
+                        ..
+                    },
+                ..
+            } => {
+                let pressed = state == ElementState::Pressed;
+                io.keys_down[key as usize] = pressed;
+                match key {
+                    VirtualKeyCode::LShift | VirtualKeyCode::RShift => io.key_shift = pressed,
+                    VirtualKeyCode::LControl | VirtualKeyCode::RControl => io.key_ctrl = pressed,
+                    VirtualKeyCode::LAlt | VirtualKeyCode::RAlt => io.key_alt = pressed,
+                    VirtualKeyCode::LWin | VirtualKeyCode::RWin => io.key_super = pressed,
+                    _ => (),
+                }
+
+                io.want_capture_keyboard
+            }
+            WindowEvent::ReceivedCharacter(ch) => {
+                io.add_input_character(ch);
+
+                io.want_capture_keyboard
+            }
+
+            WindowEvent::CursorMoved { position, .. } => {
+                io.mouse_pos = [position.x as f32, position.y as f32];
+
+                io.want_capture_mouse
+            }
+            WindowEvent::MouseWheel {
+                delta,
+                phase: TouchPhase::Moved,
+                ..
+            } => {
+                match delta {
+                    MouseScrollDelta::LineDelta(h, v) => {
+                        io.mouse_wheel_h = h;
+                        io.mouse_wheel = v;
+                    }
+                    MouseScrollDelta::PixelDelta(pos) => {
+                        match pos.x.partial_cmp(&0.0) {
+                            Some(std::cmp::Ordering::Greater) => io.mouse_wheel_h += 1.0,
+                            Some(std::cmp::Ordering::Less) => io.mouse_wheel_h -= 1.0,
+                            _ => (),
+                        }
+                        match pos.y.partial_cmp(&0.0) {
+                            Some(std::cmp::Ordering::Greater) => io.mouse_wheel += 1.0,
+                            Some(std::cmp::Ordering::Less) => io.mouse_wheel -= 1.0,
+                            _ => (),
+                        }
+                    }
+                }
+
+                io.want_capture_mouse
+            }
+            WindowEvent::MouseInput { state, button, .. } => {
+                let pressed = state == ElementState::Pressed;
+                match button {
+                    MouseButton::Left => io.mouse_down[0] = pressed,
+                    MouseButton::Right => io.mouse_down[1] = pressed,
+                    MouseButton::Middle => io.mouse_down[2] = pressed,
+                    MouseButton::Other(idx @ 0..=4) => io.mouse_down[idx as usize] = pressed,
+                    MouseButton::Other(_) => (),
+                }
+
+                io.want_capture_mouse
+            }
+            _ => false,
+        },
+        // Track key release events outside our window. If we don't do this,
+        // we might never see the release event if some other window gets focus.
+        Event::DeviceEvent {
+            event:
+                DeviceEvent::Key(KeyboardInput {
+                    state: ElementState::Released,
+                    virtual_keycode: Some(key),
+                    ..
+                }),
+            ..
+        } => {
+            io.keys_down[*key as usize] = false;
+            match *key {
+                VirtualKeyCode::LShift | VirtualKeyCode::RShift => io.key_shift = false,
+                VirtualKeyCode::LControl | VirtualKeyCode::RControl => io.key_ctrl = false,
+                VirtualKeyCode::LAlt | VirtualKeyCode::RAlt => io.key_alt = false,
+                VirtualKeyCode::LWin | VirtualKeyCode::RWin => io.key_super = false,
+                _ => (),
+            }
+
+            io.want_capture_keyboard
+        }
+        _ => false,
+    }
+}

examples/vulkan-visualization/main.rs

@@ -1,17 +1,15 @@
-use ash::vk;
-
 use std::default::Default;
 use std::ffi::CString;
 
+use ash::vk;
 use gpu_allocator::vulkan::{Allocator, AllocatorCreateDesc};
-
-mod helper;
-use helper::record_and_submit_command_buffer;
+use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
 
 mod imgui_renderer;
-use imgui_renderer::ImGuiRenderer;
+use imgui_renderer::{handle_imgui_event, ImGuiRenderer};
 
-use imgui_winit_support::{HiDpiMode, WinitPlatform};
+mod helper;
+use helper::record_and_submit_command_buffer;
 
 fn main() -> ash::prelude::VkResult<()> {
     let entry = unsafe { ash::Entry::load() }.unwrap();
@@ -21,7 +19,7 @@ fn main() -> ash::prelude::VkResult<()> {
     let window_width = 1920;
     let window_height = 1080;
     let window = winit::window::WindowBuilder::new()
-        .with_title("gpu-allocator vulkan visualization")
+        .with_title("gpu-allocator Vulkan visualization")
         .with_inner_size(winit::dpi::PhysicalSize::new(
             window_width as f64,
             window_height as f64,
@@ -30,7 +28,7 @@ fn main() -> ash::prelude::VkResult<()> {
         .build(&event_loop)
         .unwrap();
 
-    // Create vulkan instance
+    // Create Vulkan instance
     let instance = {
         let app_name = CString::new("gpu-allocator examples vulkan-visualization").unwrap();
 
@@ -47,7 +45,8 @@ fn main() -> ash::prelude::VkResult<()> {
             .map(|raw_name| raw_name.as_ptr())
             .collect();
 
-        let surface_extensions = ash_window::enumerate_required_extensions(&window).unwrap();
+        let surface_extensions =
+            ash_window::enumerate_required_extensions(event_loop.raw_display_handle()).unwrap();
 
         let create_info = vk::InstanceCreateInfo::builder()
             .application_info(&appinfo)
@@ -61,10 +60,19 @@ fn main() -> ash::prelude::VkResult<()> {
         }
     };
 
-    let surface = unsafe { ash_window::create_surface(&entry, &instance, &window, None) }.unwrap();
+    let surface = unsafe {
+        ash_window::create_surface(
+            &entry,
+            &instance,
+            window.raw_display_handle(),
+            window.raw_window_handle(),
+            None,
+        )
+    }
+    .unwrap();
     let surface_loader = ash::extensions::khr::Surface::new(&entry, &instance);
 
-    // Look for vulkan physical device
+    // Look for Vulkan physical device
     let (pdevice, queue_family_index) = {
         let pdevices = unsafe {
             instance
@@ -97,7 +105,7 @@ fn main() -> ash::prelude::VkResult<()> {
             .expect("Couldn't find suitable device.")
     };
 
-    // Create vulkan device
+    // Create Vulkan device
     let device = {
         let device_extension_names_raw = [ash::extensions::khr::Swapchain::name().as_ptr()];
         let features = vk::PhysicalDeviceFeatures {
@@ -239,13 +247,7 @@ fn main() -> ash::prelude::VkResult<()> {
         unsafe { device.create_semaphore(&semaphore_create_info, None) }.unwrap();
 
     let mut imgui = imgui::Context::create();
-    let mut platform = WinitPlatform::init(&mut imgui);
-    // imgui.io_mut().display_size = [window_width as f32, window_height as f32];
-    platform.attach_window(
-        imgui.io_mut(),
-        &window,
-        HiDpiMode::Rounded, /* Default is blurry! */
-    );
+    imgui.io_mut().display_size = [window_width as f32, window_height as f32];
 
     let descriptor_pool = {
         let pool_sizes = [
@@ -294,12 +296,11 @@ fn main() -> ash::prelude::VkResult<()> {
         .collect::<Vec<_>>();
 
     let mut visualizer = Some(gpu_allocator::vulkan::AllocatorVisualizer::new());
-    let mut last_frame = std::time::Instant::now();
 
     event_loop.run(move |event, _, control_flow| {
         *control_flow = winit::event_loop::ControlFlow::Wait;
 
-        platform.handle_event(imgui.io_mut(), &window, &event);
+        handle_imgui_event(imgui.io_mut(), &window, &event);
 
         let mut ready_for_rendering = false;
         match event {
@@ -318,11 +319,6 @@ fn main() -> ash::prelude::VkResult<()> {
                 _ => {}
             },
             winit::event::Event::MainEventsCleared => ready_for_rendering = true,
-            winit::event::Event::NewEvents(_) => {
-                let now = std::time::Instant::now();
-                imgui.io_mut().update_delta_time(now - last_frame);
-                last_frame = now;
-            }
             _ => {}
         }
 
@@ -338,9 +334,6 @@ fn main() -> ash::prelude::VkResult<()> {
             .unwrap();
 
             // Start ImGui frame
-            platform
-                .prepare_frame(imgui.io_mut(), &window)
-                .expect("Failed to prepare frame");
             let ui = imgui.frame();
 
             // Submit visualizer ImGui commands
@@ -350,7 +343,6 @@ fn main() -> ash::prelude::VkResult<()> {
                 .render(allocator.as_ref().unwrap(), &ui, None);
 
             // Finish ImGui Frame
-            platform.prepare_render(&ui, &window);
             let imgui_draw_data = ui.render();
 
             record_and_submit_command_buffer(

src/d3d12/mod.rs

@@ -452,7 +452,7 @@ impl MemoryType {
                     Err(AllocationError::OutOfMemory) => {} // Block is full, continue search.
                     Err(err) => return Err(err),            // Unhandled error, return.
                 }
-            } else if empty_block_index == None {
+            } else if empty_block_index.is_none() {
                 empty_block_index = Some(mem_block_i);
             }
         }

src/vulkan/mod.rs

@@ -342,7 +342,7 @@ impl MemoryType {
                         _ => return Err(err),              // Unhandled error, return.
                     },
                 }
-            } else if empty_block_index == None {
+            } else if empty_block_index.is_none() {
                 empty_block_index = Some(mem_block_i);
             }
         }