From 395c74460185be4e246ced13ace08b09a06e200b Mon Sep 17 00:00:00 2001 From: maik klein Date: Sun, 4 Dec 2016 00:56:58 +0100 Subject: [PATCH] extended loader + lib --- ash/src/instance.rs | 281 ++++++++++++++++----- examples/src/main.rs | 86 ++++++- vk_loader2/src/lib.rs | 570 ++++++++++++++++++++++++++++++++++++++---- 3 files changed, 825 insertions(+), 112 deletions(-) diff --git a/ash/src/instance.rs b/ash/src/instance.rs index 14fc17e..fdbb965 100644 --- a/ash/src/instance.rs +++ b/ash/src/instance.rs @@ -8,80 +8,258 @@ use std::mem; use std::sync::Arc; use std::os::raw::*; use std::cell::Cell; +use std::path::Path; use vk_loader2 as vk; // use feature; use load; +use shared_library::dynamic_library::DynamicLibrary; +type VkResult = Result; // use fence; // use extensions::*; // use surface; // use device::*; -#[derive(Debug)] -pub struct Instance { - handle: vk::Instance, - instance_fn: vk::InstanceFn, +// macro_rules! vk_error( +// ($err_name: ident, $($raw_name: ident => $name: ident,)*) => { +// #[derive(Debug)] +// pub enum $err_name { +// $( +// $name, +// )* +// } +// impl From for $err_name { +// fn from(r: vk::Result) -> $err_name { +// match r { +// $( +// vk::Result::$raw_name => $err_name::$name, +// )* +// _ => panic!("Missing error case for '{}', please open an issue.", stringify!($err_name)), +// } +// } +// } +// } +// ); + +#[cfg(windows)] +fn get_path() -> &'static Path { + Path::new("vulkan-1.dll") } -macro_rules! vk_error( - ($err_name: ident, $($raw_name: ident => $name: ident,)*) => { - #[derive(Debug)] - pub enum $err_name { - $( - $name, - )* - } - impl From for $err_name { - fn from(r: vk::Result) -> $err_name { - match r { - $( - vk::Result::$raw_name => $err_name::$name, - )* - _ => panic!("Missing error case for '{}', please open an issue.", stringify!($err_name)), - } - } - } +#[cfg(all(unix, not(target_os = "android")))] +fn get_path() -> &'static Path { + Path::new("libvulkan.so.1") +} + +#[cfg(target_os = "android")] +fn get_path() -> &'static Path { + Path::new("libvulkan.so") +} + +#[derive(Debug)] +pub struct Instance<'r> { + handle: vk::Instance, + instance_fn: vk::InstanceFn, + _lifetime: ::std::marker::PhantomData<&'r i32>, +} + +pub struct Entry { + lib: DynamicLibrary, + static_fn: vk::Static, + entry_fn: vk::EntryFn, +} + +#[derive(Debug)] +pub enum LoadingError { + LibraryLoadFailure(String), + StaticLoadError(String), + EntryLoadError(String), +} + +impl Entry { + pub fn load_vulkan_path(path: &Path) -> Result { + let lib = try!(DynamicLibrary::open(Some(path)) + .map_err(|err| LoadingError::LibraryLoadFailure(err))); + let static_fn = try!(vk::Static::load(|name| unsafe { + let name = name.to_str().unwrap(); + let f = match lib.symbol(name) { + Ok(s) => s, + Err(_) => ptr::null(), + }; + f + }) + .map_err(|err| LoadingError::StaticLoadError(err))); + let entry_fn = try!(vk::EntryFn::load(|name| unsafe { + mem::transmute(static_fn.get_instance_proc_addr(ptr::null_mut(), name.as_ptr())) + }) + .map_err(|err| LoadingError::EntryLoadError(err))); + Ok(Entry { + lib: lib, + static_fn: static_fn, + entry_fn: entry_fn, + }) + } + pub fn load_vulkan() -> Result { + Entry::load_vulkan_path(get_path()) } -); -vk_error!( - InstanceError, - ErrorOutOfHostMemory => OutOfHostMemory, - ErrorOutOfDeviceMemory => OutOfDeviceMemory, - ErrorInitializationFailed => InitializationFailed, - ErrorIncompatibleDriver => IncompatibleDriver, -); -vk_error!( - EnumerateDeviceError, - ErrorOutOfHostMemory => OutOfHostMemory, - ErrorOutOfDeviceMemory => OutOfDeviceMemory, - ErrorInitializationFailed => InitializationFailed, -); - -impl Instance { - // FIX: Add loading error - pub fn create_instance>(i: I) -> Result { + pub fn create_instance>(&self, + i: I) + -> Result { let create_info = i.into(); - let static_fn = load::static_fn().unwrap(); - let entry = load::entry_fn(&static_fn); unsafe { let mut instance: vk::Instance = mem::uninitialized(); - let err_code = entry.create_instance(&create_info, ptr::null(), &mut instance); + let err_code = self.entry_fn.create_instance(&create_info, ptr::null(), &mut instance); if err_code != vk::Result::Success { return Err(err_code); } let instance_fn = vk::InstanceFn::load(|name| unsafe { - mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr())) + mem::transmute(self.static_fn.get_instance_proc_addr(instance, name.as_ptr())) }) .unwrap(); Ok(Instance { handle: instance, instance_fn: instance_fn, + _lifetime: ::std::marker::PhantomData, }) } } - pub fn enumerate_physical_devices(&self) -> Result, vk::Result> { + pub fn enumerate_instance_layer_properties(&self) + -> Result, vk::Result> { + unsafe { + let mut num = 0; + self.entry_fn.enumerate_instance_layer_properties(&mut num, ptr::null_mut()); + + let mut v = Vec::with_capacity(num as usize); + let err_code = self.entry_fn + .enumerate_instance_layer_properties(&mut num, v.as_mut_ptr()); + v.set_len(num as usize); + match err_code { + vk::Result::Success => Ok(v), + _ => Err(err_code), + } + } + } + + pub fn enumerate_instance_extension_properties + (&self) + -> Result, vk::Result> { + unsafe { + let mut num = 0; + self.entry_fn + .enumerate_instance_extension_properties(ptr::null(), &mut num, ptr::null_mut()); + let mut data = Vec::with_capacity(num as usize); + let err_code = self.entry_fn + .enumerate_instance_extension_properties(ptr::null(), &mut num, data.as_mut_ptr()); + data.set_len(num as usize); + match err_code { + vk::Result::Success => Ok(data), + _ => Err(err_code), + } + } + } +} + +pub struct Device { + handle: vk::Device, + device_fn: vk::DeviceFn, +} +impl Device { + pub fn destroy_device(&self) { + unsafe { + self.device_fn.destroy_device(self.handle, ptr::null()); + } + } +} + +impl<'r> Instance<'r> { + pub fn destroy_instance(&self) { + unsafe { + self.instance_fn.destroy_instance(self.handle, ptr::null()); + } + } + + pub fn destroy_surface_khr(&self, surface: vk::SurfaceKHR) { + unsafe { + self.instance_fn.destroy_surface_khr(self.handle, surface, ptr::null()); + } + } + pub fn create_xlib_surface_khr> + (&self, + i: I) + -> VkResult { + let create_info = i.into(); + unsafe { + let mut surface = mem::uninitialized(); + let err_code = self.instance_fn + .create_xlib_surface_khr(self.handle, &create_info, ptr::null(), &mut surface); + match err_code { + vk::Result::Success => Ok(surface), + _ => Err(err_code), + } + } + + } + pub fn get_physical_device_surface_support_khr(&self, + physical_device: vk::PhysicalDevice, + queue_index: u32, + surface: vk::SurfaceKHR) + -> bool { + unsafe { + let mut b = mem::uninitialized(); + self.instance_fn + .get_physical_device_surface_support_khr(physical_device, + queue_index, + surface, + &mut b); + b > 0 + } + + } + pub fn get_physical_device_queue_family_properties(&self, + physical_device: vk::PhysicalDevice) + -> Vec { + unsafe { + let mut queue_count = 0; + self.instance_fn + .get_physical_device_queue_family_properties(physical_device, + &mut queue_count, + ptr::null_mut()); + let mut queue_families_vec = Vec::with_capacity(queue_count as usize); + let err_code = self.instance_fn + .get_physical_device_queue_family_properties(physical_device, + &mut queue_count, + queue_families_vec.as_mut_ptr()); + queue_families_vec.set_len(queue_count as usize); + queue_families_vec + } + } + + pub fn create_device>(&self, + physical_device: vk::PhysicalDevice, + i: I) + -> VkResult { + let create_info = i.into(); + unsafe { + let mut device = mem::uninitialized(); + let err_code = self.instance_fn + .create_device(physical_device, &create_info, ptr::null(), &mut device); + if err_code != vk::Result::Success { + return Err(err_code); + } + let device_fn = vk::DeviceFn::load(|name| unsafe { + mem::transmute(self.instance_fn.get_device_proc_addr(device, name.as_ptr())) + }) + .unwrap(); + Ok(Device { + handle: device, + device_fn: device_fn, + }) + } + } + + pub fn enumerate_physical_devices(&self) -> VkResult> { unsafe { let mut num = mem::uninitialized(); self.instance_fn @@ -96,19 +274,6 @@ impl Instance { } } } - pub fn enumerate_instance_layer_properties() -> Vec { - let static_fn = load::static_fn().unwrap(); - let entry = load::entry_fn(&static_fn); - unsafe { - let mut num = 0; - entry.enumerate_instance_layer_properties(&mut num, ptr::null_mut()); - - let mut v = Vec::with_capacity(num as usize); - entry.enumerate_instance_layer_properties(&mut num, v.as_mut_ptr()); - v.set_len(num as usize); - v - } - } pub fn enumerate_device_extension_properties (&self, diff --git a/examples/src/main.rs b/examples/src/main.rs index 5d8c841..e29c6d6 100644 --- a/examples/src/main.rs +++ b/examples/src/main.rs @@ -5,16 +5,45 @@ extern crate ash; extern crate vk_loader2 as vk; extern crate glfw; -use ash::instance::Instance; +use glfw::*; +use ash::instance::{Entry, Instance}; use std::ptr; use std::ffi::{CStr, CString}; use std::mem; +use std::path::Path; +use std::os::raw::c_void; +fn handle_window_event(window: &mut glfw::Window, event: glfw::WindowEvent) { + match event { + glfw::WindowEvent::Key(Key::Escape, _, Action::Press, _) => window.set_should_close(true), + _ => {} + } +} fn main() { + let mut glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap(); + + let (mut window, events) = glfw.create_window(1920, + 1080, + "Hello this is window", + glfw::WindowMode::Windowed) + .expect("Failed to create GLFW window."); + + window.set_key_polling(true); + window.make_current(); + let entry = Entry::load_vulkan().unwrap(); + let instance_ext_props = entry.enumerate_instance_extension_properties().unwrap(); + println!("{:?}", instance_ext_props); let app_name = CString::new("TEST").unwrap(); let raw_name = app_name.as_ptr(); let lunarg_layer = CString::new("VK_LAYER_LUNARG_standard_validation").unwrap(); let layers = [lunarg_layer.as_ptr()]; + let swapchain_ext_name = CString::new("VK_KHR_swapchain").unwrap(); + let surface_ext_name = CString::new("VK_KHR_surface").unwrap(); + let surface_xlib_ext_name = CString::new("VK_KHR_xlib_surface").unwrap(); + let extensions = [// swapchain_ext_name.as_ptr(), + surface_ext_name.as_ptr(), + surface_xlib_ext_name.as_ptr()]; + let tt = [vk::VK_KHR_SURFACE_EXTENSION_NAME]; let appinfo = vk::ApplicationInfo { p_application_name: raw_name, s_type: vk::StructureType::ApplicationInfo, @@ -30,17 +59,56 @@ fn main() { p_next: ptr::null(), pp_enabled_layer_names: layers.as_ptr(), enabled_layer_count: layers.len() as u32, - pp_enabled_extension_names: ptr::null(), - enabled_extension_count: 0, + pp_enabled_extension_names: extensions.as_ptr(), + enabled_extension_count: extensions.len() as u32, flags: 0, }; - let instance = Instance::create_instance(create_info).expect("Instance creation error"); - println!("{:?}", instance); + let instance = entry.create_instance(create_info).expect("Instance creation error"); + let x11_display = window.glfw.get_x11_display(); + let x11_window = window.get_x11_window(); + let x11_create_info = vk::XlibSurfaceCreateInfoKHR { + s_type: vk::StructureType::XlibSurfaceCreateInfoKhr, + p_next: ptr::null(), + flags: 0, + window: x11_window as vk::Window, + dpy: x11_display as *mut vk::Display, + }; + let surface = instance.create_xlib_surface_khr(x11_create_info).unwrap(); let pdevices = instance.enumerate_physical_devices().expect("Physical device error"); - println!("{:?}", pdevices); - let ext_props = instance.enumerate_device_extension_properties(pdevices[0]) - .expect("Enumerate device error"); - println!("{:?}", ext_props); + let pdevice = pdevices[0]; + let pdevice_info = instance.get_physical_device_queue_family_properties(pdevice); + let (queue_family_index, _) = pdevice_info.iter() + .enumerate() + .filter(|&(index, ref info)| info.queue_flags.subset(vk::QUEUE_GRAPHICS_BIT)) + .nth(0) + .expect("Could not find any suitable queue"); + println!("{:?}", pdevice_info); + let priorities = [1.0]; + let queue_info = vk::DeviceQueueCreateInfo { + s_type: vk::StructureType::DeviceQueueCreateInfo, + p_next: ptr::null(), + flags: 0, + queue_family_index: queue_family_index as u32, + p_queue_priorities: priorities.as_ptr(), + queue_count: priorities.len() as u32, + }; + let device_create_info = vk::DeviceCreateInfo { + s_type: vk::StructureType::DeviceCreateInfo, + p_next: ptr::null(), + flags: 0, + queue_create_info_count: 1, + p_queue_create_infos: &queue_info, + enabled_layer_count: 0, + pp_enabled_layer_names: ptr::null(), + enabled_extension_count: 0, + pp_enabled_extension_names: ptr::null(), + p_enabled_features: ptr::null(), + }; + let device = instance.create_device(pdevices[0], device_create_info).unwrap(); + + device.destroy_device(); + instance.destroy_surface_khr(surface); + instance.destroy_instance(); } // use ash::instance::*; // use vk_loader as vk; diff --git a/vk_loader2/src/lib.rs b/vk_loader2/src/lib.rs index 0d2faa6..63c81ce 100644 --- a/vk_loader2/src/lib.rs +++ b/vk_loader2/src/lib.rs @@ -203,6 +203,19 @@ pub type uint64_t = u64; pub type uint8_t = u8; pub type c_float = f32; pub type int32_t = i32; +pub type Display = *const (); +pub type Window = *const (); +pub type VisualID = *const (); +pub type xcb_connection_t = *const (); +pub type xcb_window_t = *const (); +pub type xcb_visualid_t = *const (); +pub type MirConnection = *const (); +pub type MirSurface = *const (); +pub type HINSTANCE = *const (); +pub type HWND = *const (); +pub type ANativeWindow = *const (); +pub type wl_display = *const (); +pub type wl_surface = *const (); pub type InstanceCreateFlags = Flags; pub type Flags = uint32_t; @@ -236,6 +249,15 @@ pub type DescriptorPoolResetFlags = Flags; pub type FramebufferCreateFlags = Flags; pub type RenderPassCreateFlags = Flags; pub type SubpassDescriptionFlags = Flags; +pub type XlibSurfaceCreateFlagsKHR = Flags; +pub type XcbSurfaceCreateFlagsKHR = Flags; +pub type MirSurfaceCreateFlagsKHR = Flags; +pub type Win32SurfaceCreateFlagsKHR = Flags; +pub type AndroidSurfaceCreateFlagsKHR = Flags; +pub type WaylandSurfaceCreateFlagsKHR = Flags; +pub type SwapchainCreateFlagsKHR = Flags; +pub type DisplayModeCreateFlagsKHR = Flags; +pub type DisplaySurfaceCreateFlagsKHR = Flags; pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: size_t = 256; pub const VK_UUID_SIZE: size_t = 16; @@ -254,6 +276,26 @@ pub const VK_QUEUE_FAMILY_IGNORED: uint32_t = !0; pub const VK_SUBPASS_EXTERNAL: uint32_t = !0; pub const VK_KHR_SURFACE_SPEC_VERSION: uint32_t = 25; pub const VK_KHR_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_surface"; +pub const VK_KHR_XLIB_SURFACE_SPEC_VERSION: uint32_t = 6; +pub const VK_KHR_XLIB_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_xlib_surface"; +pub const VK_KHR_XCB_SURFACE_SPEC_VERSION: uint32_t = 6; +pub const VK_KHR_XCB_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_xcb_surface"; +pub const VK_KHR_MIR_SURFACE_SPEC_VERSION: uint32_t = 4; +pub const VK_KHR_MIR_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_mir_surface"; +pub const VK_KHR_WIN32_SURFACE_SPEC_VERSION: uint32_t = 5; +pub const VK_KHR_WIN32_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_win32_surface"; +pub const VK_KHR_ANDROID_SURFACE_SPEC_VERSION: uint32_t = 6; +pub const VK_KHR_ANDROID_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_android_surface"; +pub const VK_KHR_WAYLAND_SURFACE_SPEC_VERSION: uint32_t = 5; +pub const VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_wayland_surface"; +pub const VK_KHR_SWAPCHAIN_SPEC_VERSION: uint32_t = 68; +pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME: &'static str = "VK_KHR_swapchain"; +pub const VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION: uint32_t = 9; +pub const VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME: &'static str = "VK_KHR_display_swapchain"; +pub const VK_KHR_DISPLAY_SPEC_VERSION: uint32_t = 21; +pub const VK_KHR_DISPLAY_EXTENSION_NAME: &'static str = "VK_KHR_display"; +pub const VK_EXT_DEBUG_REPORT_SPEC_VERSION: uint32_t = 3; +pub const VK_EXT_DEBUG_REPORT_EXTENSION_NAME: &'static str = "VK_EXT_debug_report"; #[derive(Debug, Clone)] #[repr(C)] @@ -2069,6 +2111,215 @@ pub struct SurfaceFormatKHR { pub color_space: ColorSpaceKHR, } +#[derive(Debug, Clone)] +#[repr(C)] +pub struct XlibSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: XlibSurfaceCreateFlagsKHR, + pub dpy: *mut Display, + pub window: Window, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct XcbSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: XcbSurfaceCreateFlagsKHR, + pub connection: *mut xcb_connection_t, + pub window: xcb_window_t, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct MirSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MirSurfaceCreateFlagsKHR, + pub connection: *mut MirConnection, + pub mir_surface: *mut MirSurface, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct Win32SurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: Win32SurfaceCreateFlagsKHR, + pub hinstance: HINSTANCE, + pub hwnd: HWND, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct AndroidSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: AndroidSurfaceCreateFlagsKHR, + pub window: *mut ANativeWindow, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct WaylandSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: WaylandSurfaceCreateFlagsKHR, + pub display: *mut wl_display, + pub surface: *mut wl_surface, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct SwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SwapchainCreateFlagsKHR, + pub surface: SurfaceKHR, + pub min_image_count: uint32_t, + pub image_format: Format, + pub image_color_space: ColorSpaceKHR, + pub image_extent: Extent2D, + pub image_array_layers: uint32_t, + pub image_usage: ImageUsageFlags, + pub image_sharing_mode: SharingMode, + pub queue_family_index_count: uint32_t, + pub p_queue_family_indices: *const uint32_t, + pub pre_transform: SurfaceTransformFlagsKHR, + pub composite_alpha: CompositeAlphaFlagsKHR, + pub present_mode: PresentModeKHR, + pub clipped: Bool32, + pub old_swapchain: SwapchainKHR, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct PresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: uint32_t, + pub p_wait_semaphores: *const Semaphore, + pub swapchain_count: uint32_t, + pub p_swapchains: *const SwapchainKHR, + pub p_image_indices: *const uint32_t, + pub p_results: *mut Result, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct DisplayPresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_rect: Rect2D, + pub dst_rect: Rect2D, + pub persistent: Bool32, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct DisplayPropertiesKHR { + pub display: DisplayKHR, + pub display_name: *const c_char, + pub physical_dimensions: Extent2D, + pub physical_resolution: Extent2D, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub plane_reorder_possible: Bool32, + pub persistent_content: Bool32, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct DisplayModeParametersKHR { + pub visible_region: Extent2D, + pub refresh_rate: uint32_t, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct DisplayModePropertiesKHR { + pub display_mode: DisplayModeKHR, + pub parameters: DisplayModeParametersKHR, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct DisplayModeCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DisplayModeCreateFlagsKHR, + pub parameters: DisplayModeParametersKHR, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct DisplayPlaneCapabilitiesKHR { + pub supported_alpha: DisplayPlaneAlphaFlagsKHR, + pub min_src_position: Offset2D, + pub max_src_position: Offset2D, + pub min_src_extent: Extent2D, + pub max_src_extent: Extent2D, + pub min_dst_position: Offset2D, + pub max_dst_position: Offset2D, + pub min_dst_extent: Extent2D, + pub max_dst_extent: Extent2D, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct DisplayPlanePropertiesKHR { + pub current_display: DisplayKHR, + pub current_stack_index: uint32_t, +} + +#[derive(Debug, Clone)] +#[repr(C)] +pub struct DisplaySurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DisplaySurfaceCreateFlagsKHR, + pub display_mode: DisplayModeKHR, + pub plane_index: uint32_t, + pub plane_stack_index: uint32_t, + pub transform: SurfaceTransformFlagsKHR, + pub global_alpha: c_float, + pub alpha_mode: DisplayPlaneAlphaFlagsKHR, + pub image_extent: Extent2D, +} + +#[repr(C)] +pub struct DebugReportCallbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugReportFlagsEXT, + pub pfn_callback: PFN_vkDebugReportCallbackEXT, + pub p_user_data: *mut c_void, +} + +impl Clone for DebugReportCallbackCreateInfoEXT { + fn clone(&self) -> DebugReportCallbackCreateInfoEXT { + DebugReportCallbackCreateInfoEXT { + s_type: self.s_type.clone(), + p_next: self.p_next.clone(), + flags: self.flags.clone(), + pfn_callback: self.pfn_callback, + p_user_data: self.p_user_data.clone(), + } + } +} + +impl fmt::Debug for DebugReportCallbackCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { + fmt.debug_struct("DebugReportCallbackCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("pfn_callback", &(self.pfn_callback as *const ())) + .field("p_user_data", &self.p_user_data) + .finish() + } +} + /// Temporary Hard-Coded union hack; will be automatically generated when actual unions become stable #[repr(C)] @@ -2242,6 +2493,18 @@ pub enum StructureType { MemoryBarrier = 46, LoaderInstanceCreateInfo = 47, LoaderDeviceCreateInfo = 48, + XlibSurfaceCreateInfoKhr = 1000004000, + XcbSurfaceCreateInfoKhr = 1000005000, + MirSurfaceCreateInfoKhr = 1000007000, + Win32SurfaceCreateInfoKhr = 1000009000, + AndroidSurfaceCreateInfoKhr = 1000008000, + WaylandSurfaceCreateInfoKhr = 1000006000, + SwapchainCreateInfoKhr = 1000001000, + PresentInfoKhr = 1000001001, + DisplayPresentInfoKhr = 1000003000, + DisplayModeCreateInfoKhr = 1000002000, + DisplaySurfaceCreateInfoKhr = 1000002001, + DebugReportCallbackCreateInfoExt = 1000011000, } #[repr(C)] @@ -2283,6 +2546,10 @@ pub enum Result { ErrorFragmentedPool = -12, ErrorSurfaceLostKhr = -1000000000, ErrorNativeWindowInUseKhr = -1000000001, + SuboptimalKhr = 1000001003, + ErrorOutOfDateKhr = -1000001004, + ErrorIncompatibleDisplayKhr = -1000003001, + ErrorValidationFailedExt = -1000011001, } #[repr(C)] @@ -2527,6 +2794,7 @@ pub enum ImageLayout { TransferSrcOptimal = 6, TransferDstOptimal = 7, Preinitialized = 8, + PresentSrcKhr = 1000001002, } #[repr(C)] @@ -2794,6 +3062,47 @@ pub enum PresentModeKHR { FifoRelaxed = 3, } +#[repr(C)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum DebugReportObjectTypeEXT { + Unknown = 0, + Instance = 1, + PhysicalDevice = 2, + Device = 3, + Queue = 4, + Semaphore = 5, + CommandBuffer = 6, + Fence = 7, + DeviceMemory = 8, + Buffer = 9, + Image = 10, + Ent = 11, + QueryPool = 12, + BufferView = 13, + ImageView = 14, + ShaderModule = 15, + PipelineCache = 16, + PipelineLayout = 17, + RenderPass = 18, + Pipeline = 19, + DescriptorSetLayout = 20, + Sampler = 21, + DescriptorPool = 22, + DescriptorSet = 23, + Framebuffer = 24, + CommandPool = 25, + SurfaceKhr = 26, + SwapchainKhr = 27, + DebugReport = 28, +} + +#[repr(C)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum DebugReportErrorEXT { + None = 0, + CallbackRef = 1, +} + #[repr(C)] #[doc(hidden)] @@ -2846,6 +3155,10 @@ handle_nondispatchable!(DescriptorSet); handle_nondispatchable!(Framebuffer); handle_nondispatchable!(CommandPool); handle_nondispatchable!(SurfaceKHR); +handle_nondispatchable!(SwapchainKHR); +handle_nondispatchable!(DisplayKHR); +handle_nondispatchable!(DisplayModeKHR); +handle_nondispatchable!(DebugReportCallbackEXT); pub const FORMAT_FEATURE_SAMPLED_IMAGE_BIT: FormatFeatureFlags = FormatFeatureFlags {flags: 0b1}; pub const FORMAT_FEATURE_STORAGE_IMAGE_BIT: FormatFeatureFlags = FormatFeatureFlags {flags: 0b10}; @@ -3070,6 +3383,19 @@ pub const COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: CompositeAlphaFlagsKHR = Comp pub const COMPOSITE_ALPHA_INHERIT_BIT_KHR: CompositeAlphaFlagsKHR = CompositeAlphaFlagsKHR {flags: 0b1000}; vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); +pub const DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: DisplayPlaneAlphaFlagsKHR = DisplayPlaneAlphaFlagsKHR {flags: 0b1}; +pub const DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: DisplayPlaneAlphaFlagsKHR = DisplayPlaneAlphaFlagsKHR {flags: 0b10}; +pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: DisplayPlaneAlphaFlagsKHR = DisplayPlaneAlphaFlagsKHR {flags: 0b100}; +pub const DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: DisplayPlaneAlphaFlagsKHR = DisplayPlaneAlphaFlagsKHR {flags: 0b1000}; +vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); + +pub const DEBUG_REPORT_INFORMATION_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT {flags: 0b1}; +pub const DEBUG_REPORT_WARNING_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT {flags: 0b10}; +pub const DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT {flags: 0b100}; +pub const DEBUG_REPORT_ERROR_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT {flags: 0b1000}; +pub const DEBUG_REPORT_DEBUG_BIT_EXT: DebugReportFlagsEXT = DebugReportFlagsEXT {flags: 0b10000}; +vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b11111, Flags); + pub type PFN_vkAllocationFunction = unsafe extern "system" fn( *mut c_void, @@ -3108,6 +3434,18 @@ pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn( pub type PFN_vkVoidFunction = unsafe extern "system" fn( ); +pub type PFN_vkDebugReportCallbackEXT = unsafe extern "system" fn( + DebugReportFlagsEXT, + DebugReportObjectTypeEXT, + uint64_t, + size_t, + int32_t, + *const c_char, + *const c_char, + *mut c_void, +) -> Bool32; + + } //FIX: Need better error handling for extensions macro_rules! vk_functions { @@ -3165,51 +3503,6 @@ macro_rules! vk_functions { } } - //$( - // pub unsafe extern "system" fn $name ( - // $($param_name: $param),* - // ) -> $ret { - // use std::mem; - - // mem::transmute::<_, $name::FnType>($name::fn_ptr)($($param_name),*) - // } - - // pub mod $name { - - // use super::super::*; - // #[allow(unused_imports)] - // use super::super::libc_reexports::*; - // pub const RAW_NAME: &'static str = $raw_name; - // pub static mut fn_ptr: *const () = unloaded_function_panic as *const (); - // #[doc(hidden)] - // pub type FnType = unsafe extern "system" fn($($param),*) -> $ret; - - // pub fn is_loaded() -> bool { - // unsafe{ fn_ptr == unloaded_function_panic as *const () } - // } - // } - //)+ - - //pub fn load_with *const ()>(mut load_fn: F) -> ::std::result::Result<(), Vec<&'static str>> {unsafe{ - // use std::ptr; - // let mut fn_buf: *const (); - // let mut unloaded_fns = Vec::new(); - - // $( - // fn_buf = load_fn($raw_name); - // if ptr::null() != fn_buf { - // $name::fn_ptr = fn_buf; - // } else if $name::fn_ptr != unloaded_function_panic as *const () { - // unloaded_fns.push($raw_name) - // } - // )+ - - // if 0 == unloaded_fns.len() { - // Ok(()) - // } else { - // Err(unloaded_fns) - // } - //}} } } @@ -3365,6 +3658,193 @@ vk_functions!{ p_present_mode_count: *mut uint32_t, p_present_modes: *mut PresentModeKHR, ) -> Result; + + "vkGetPhysicalDeviceXlibPresentationSupportKHR", get_physical_device_xlib_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + dpy: *mut Display, + visual_id: VisualID, + ) -> Bool32; + + "vkCreateXlibSurfaceKHR", create_xlib_surface_khr( + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + + "vkCreateXcbSurfaceKHR", create_xcb_surface_khr( + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + + "vkGetPhysicalDeviceXcbPresentationSupportKHR", get_physical_device_xcb_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *mut xcb_connection_t, + visual_id: xcb_visualid_t, + ) -> Bool32; + + "vkCreateMirSurfaceKHR", create_mir_surface_khr( + instance: Instance, + p_create_info: *const MirSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + + "vkGetPhysicalDeviceMirPresentationSupportKHR", get_physical_device_mir_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + connection: *mut MirConnection, + ) -> Bool32; + + "vkCreateWin32SurfaceKHR", create_win32_surface_khr( + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + + "vkGetPhysicalDeviceWin32PresentationSupportKHR", get_physical_device_win32_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + ) -> Bool32; + + "vkCreateAndroidSurfaceKHR", create_android_surface_khr( + instance: Instance, + p_create_info: *const AndroidSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + + "vkCreateWaylandSurfaceKHR", create_wayland_surface_khr( + instance: Instance, + p_create_info: *const WaylandSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + + "vkGetPhysicalDeviceWaylandPresentationSupportKHR", get_physical_device_wayland_presentation_support_khr( + physical_device: PhysicalDevice, + queue_family_index: uint32_t, + display: *mut wl_display, + ) -> Bool32; + + "vkCreateSwapchainKHR", create_swapchain_khr( + device: Device, + p_create_info: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchain: *mut SwapchainKHR, + ) -> Result; + + "vkDestroySwapchainKHR", destroy_swapchain_khr( + device: Device, + swapchain: SwapchainKHR, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkGetSwapchainImagesKHR", get_swapchain_images_khr( + device: Device, + swapchain: SwapchainKHR, + p_swapchain_image_count: *mut uint32_t, + p_swapchain_images: *mut Image, + ) -> Result; + + "vkAcquireNextImageKHR", acquire_next_image_khr( + device: Device, + swapchain: SwapchainKHR, + timeout: uint64_t, + semaphore: Semaphore, + fence: Fence, + p_image_index: *mut uint32_t, + ) -> Result; + + "vkQueuePresentKHR", queue_present_khr( + queue: Queue, + p_present_info: *const PresentInfoKHR, + ) -> Result; + + "vkCreateSharedSwapchainsKHR", create_shared_swapchains_khr( + device: Device, + swapchain_count: uint32_t, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *mut SwapchainKHR, + ) -> Result; + + "vkGetPhysicalDeviceDisplayPropertiesKHR", get_physical_device_display_properties_khr( + physical_device: PhysicalDevice, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPropertiesKHR, + ) -> Result; + + "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", get_physical_device_display_plane_properties_khr( + physical_device: PhysicalDevice, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayPlanePropertiesKHR, + ) -> Result; + + "vkGetDisplayPlaneSupportedDisplaysKHR", get_display_plane_supported_displays_khr( + physical_device: PhysicalDevice, + plane_index: uint32_t, + p_display_count: *mut uint32_t, + p_displays: *mut DisplayKHR, + ) -> Result; + + "vkGetDisplayModePropertiesKHR", get_display_mode_properties_khr( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *mut uint32_t, + p_properties: *mut DisplayModePropertiesKHR, + ) -> Result; + + "vkCreateDisplayModeKHR", create_display_mode_khr( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *mut DisplayModeKHR, + ) -> Result; + + "vkGetDisplayPlaneCapabilitiesKHR", get_display_plane_capabilities_khr( + physical_device: PhysicalDevice, + mode: DisplayModeKHR, + plane_index: uint32_t, + p_capabilities: *mut DisplayPlaneCapabilitiesKHR, + ) -> Result; + + "vkCreateDisplayPlaneSurfaceKHR", create_display_plane_surface_khr( + instance: Instance, + p_create_info: *const DisplaySurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result; + + "vkCreateDebugReportCallbackEXT", create_debug_report_callback_ext( + instance: Instance, + p_create_info: *const DebugReportCallbackCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_callback: *mut DebugReportCallbackEXT, + ) -> Result; + + "vkDestroyDebugReportCallbackEXT", destroy_debug_report_callback_ext( + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, + ) -> (); + + "vkDebugReportMessageEXT", debug_report_message_ext( + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: uint64_t, + location: size_t, + message_code: int32_t, + p_layer_prefix: *const c_char, + p_message: *const c_char, + ) -> (); } vk_functions!{