src/instance/debug.rs - platform/external/rust/crates/vulkano - Git at Google

 // Copyright (c) 2016 The vulkano developers
 // Licensed under the Apache License, Version 2.0
 // <LICENSE-APACHE or
 // https://www.apache.org/licenses/LICENSE-2.0> or the MIT
 // license <LICENSE-MIT or https://opensource.org/licenses/MIT>,
 // at your option. All files in the project carrying such
 // notice may not be copied, modified, or distributed except
 // according to those terms.

 //! Debug callback called by intermediate layers or by the driver.
 //!
 //! When working on an application, it is recommended to register a debug callback. For example if
 //! you enable the validation layers provided by the official Vulkan SDK, they will warn you about
 //! invalid API usages or performance problems by calling this callback. The callback can also
 //! be called by the driver or by whatever intermediate layer is activated.
 //!
 //! Note that the vulkano library can also emit messages to warn you about performance issues.
 //! TODO: ^ that's not the case yet, need to choose whether we keep this idea
 //!
 //! # Example
 //!
 //! ```
 //! # use vulkano::instance::Instance;
 //! # use std::sync::Arc;
 //! # let instance: Arc<Instance> = return;
 //! use vulkano::instance::debug::DebugCallback;
 //!
 //! let _callback = DebugCallback::errors_and_warnings(&instance, |msg| {
 //!     println!("Debug callback: {:?}", msg.description);
 //! }).ok();
 //! ```
 //!
 //! The type of `msg` in the callback is [`Message`](struct.Message.html).
 //!
 //! Note that you must keep the `_callback` object alive for as long as you want your callback to
 //! be callable. If you don't store the return value of `DebugCallback`'s constructor in a
 //! variable, it will be immediately destroyed and your callback will not work.
 //!

 use crate::check_errors;
 use crate::instance::Instance;
 use crate::Error;
 use crate::VulkanObject;
 use std::error;
 use std::ffi::CStr;
 use std::fmt;
 use std::mem::MaybeUninit;
 use std::os::raw::c_void;
 use std::panic;
 use std::ptr;
 use std::sync::Arc;

 /// Registration of a callback called by validation layers.
 ///
 /// The callback can be called as long as this object is alive.
 #[must_use = "The DebugCallback object must be kept alive for as long as you want your callback \
               to be called"]
 pub struct DebugCallback {
     instance: Arc<Instance>,
     debug_report_callback: ash::vk::DebugUtilsMessengerEXT,
     user_callback: Box<Box<dyn Fn(&Message) + Send>>,
 }

 impl DebugCallback {
     /// Initializes a debug callback.
     ///
     /// Panics generated by calling `user_callback` are ignored.
     pub fn new<F>(
         instance: &Arc<Instance>,
         severity: MessageSeverity,
         ty: MessageType,
         user_callback: F,
     ) -> Result<DebugCallback, DebugCallbackCreationError>
     where
         F: Fn(&Message) + 'static + Send + panic::RefUnwindSafe,
     {
         if !instance.enabled_extensions().ext_debug_utils {
             return Err(DebugCallbackCreationError::MissingExtension);
         }

         // Note that we need to double-box the callback, because a `*const Fn()` is a fat pointer
         // that can't be cast to a `*const c_void`.
         let user_callback = Box::new(Box::new(user_callback) as Box<_>);

         unsafe extern "system" fn callback(
             severity: ash::vk::DebugUtilsMessageSeverityFlagsEXT,
             ty: ash::vk::DebugUtilsMessageTypeFlagsEXT,
             callback_data: *const ash::vk::DebugUtilsMessengerCallbackDataEXT,
             user_data: *mut c_void,
         ) -> ash::vk::Bool32 {
             let user_callback = user_data as *mut Box<dyn Fn()> as *const _;
             let user_callback: &Box<dyn Fn(&Message)> = &*user_callback;

             let layer_prefix = (*callback_data)
                 .p_message_id_name
                 .as_ref()
                 .map(|msg_id_name| {
                     CStr::from_ptr(msg_id_name)
                         .to_str()
                         .expect("debug callback message not utf-8")
                 });

             let description = CStr::from_ptr((*callback_data).p_message)
                 .to_str()
                 .expect("debug callback message not utf-8");

             let message = Message {
                 severity: MessageSeverity {
                     information: !(severity & ash::vk::DebugUtilsMessageSeverityFlagsEXT::INFO)
                         .is_empty(),
                     warning: !(severity & ash::vk::DebugUtilsMessageSeverityFlagsEXT::WARNING)
                         .is_empty(),
                     error: !(severity & ash::vk::DebugUtilsMessageSeverityFlagsEXT::ERROR)
                         .is_empty(),
                     verbose: !(severity & ash::vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE)
                         .is_empty(),
                 },
                 ty: MessageType {
                     general: !(ty & ash::vk::DebugUtilsMessageTypeFlagsEXT::GENERAL).is_empty(),
                     validation: !(ty & ash::vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION)
                         .is_empty(),
                     performance: !(ty & ash::vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE)
                         .is_empty(),
                 },
                 layer_prefix,
                 description,
             };

             // Since we box the closure, the type system doesn't detect that the `UnwindSafe`
             // bound is enforced. Therefore we enforce it manually.
             let _ = panic::catch_unwind(panic::AssertUnwindSafe(move || {
                 user_callback(&message);
             }));

             ash::vk::FALSE
         }

         let severity = {
             let mut flags = ash::vk::DebugUtilsMessageSeverityFlagsEXT::empty();
             if severity.information {
                 flags |= ash::vk::DebugUtilsMessageSeverityFlagsEXT::INFO;
             }
             if severity.warning {
                 flags |= ash::vk::DebugUtilsMessageSeverityFlagsEXT::WARNING;
             }
             if severity.error {
                 flags |= ash::vk::DebugUtilsMessageSeverityFlagsEXT::ERROR;
             }
             if severity.verbose {
                 flags |= ash::vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE;
             }
             flags
         };

         let ty = {
             let mut flags = ash::vk::DebugUtilsMessageTypeFlagsEXT::empty();
             if ty.general {
                 flags |= ash::vk::DebugUtilsMessageTypeFlagsEXT::GENERAL;
             }
             if ty.validation {
                 flags |= ash::vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION;
             }
             if ty.performance {
                 flags |= ash::vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE;
             }
             flags
         };

         let infos = ash::vk::DebugUtilsMessengerCreateInfoEXT {
             flags: ash::vk::DebugUtilsMessengerCreateFlagsEXT::empty(),
             message_severity: severity,
             message_type: ty,
             pfn_user_callback: Some(callback),
             p_user_data: &*user_callback as &Box<_> as *const Box<_> as *const c_void as *mut _,
             ..Default::default()
         };

         let fns = instance.fns();

         let debug_report_callback = unsafe {
             let mut output = MaybeUninit::uninit();
             check_errors(fns.ext_debug_utils.create_debug_utils_messenger_ext(
                 instance.internal_object(),
                 &infos,
                 ptr::null(),
                 output.as_mut_ptr(),
             ))?;
             output.assume_init()
         };

         Ok(DebugCallback {
             instance: instance.clone(),
             debug_report_callback,
             user_callback,
         })
     }

     /// Initializes a debug callback with errors and warnings.
     ///
     /// Shortcut for `new(instance, MessageTypes::errors_and_warnings(), user_callback)`.
     #[inline]
     pub fn errors_and_warnings<F>(
         instance: &Arc<Instance>,
         user_callback: F,
     ) -> Result<DebugCallback, DebugCallbackCreationError>
     where
         F: Fn(&Message) + Send + 'static + panic::RefUnwindSafe,
     {
         DebugCallback::new(
             instance,
             MessageSeverity::errors_and_warnings(),
             MessageType::general(),
             user_callback,
         )
     }
 }

 impl Drop for DebugCallback {
     #[inline]
     fn drop(&mut self) {
         unsafe {
             let fns = self.instance.fns();
             fns.ext_debug_utils.destroy_debug_utils_messenger_ext(
                 self.instance.internal_object(),
                 self.debug_report_callback,
                 ptr::null(),
             );
         }
     }
 }

 /// A message received by the callback.
 pub struct Message<'a> {
     /// Severity of message.
     pub severity: MessageSeverity,
     /// Type of message,
     pub ty: MessageType,
     /// Prefix of the layer that reported this message or `None` if unknown.
     pub layer_prefix: Option<&'a str>,
     /// Description of the message.
     pub description: &'a str,
 }

 /// Severity of message.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct MessageSeverity {
     /// An error that may cause undefined results, including an application crash.
     pub error: bool,
     /// An unexpected use.
     pub warning: bool,
     /// An informational message that may be handy when debugging an application.
     pub information: bool,
     /// Diagnostic information from the loader and layers.
     pub verbose: bool,
 }

 impl MessageSeverity {
     /// Builds a `MessageSeverity` with all fields set to `false` expect `error`.
     #[inline]
     pub const fn errors() -> MessageSeverity {
         MessageSeverity {
             error: true,
             ..MessageSeverity::none()
         }
     }

     /// Builds a `MessageSeverity` with all fields set to `false` expect `warning`.
     #[inline]
     pub const fn warnings() -> MessageSeverity {
         MessageSeverity {
             warning: true,
             ..MessageSeverity::none()
         }
     }

     /// Builds a `MessageSeverity` with all fields set to `false` expect `information`.
     #[inline]
     pub const fn information() -> MessageSeverity {
         MessageSeverity {
             information: true,
             ..MessageSeverity::none()
         }
     }

     /// Builds a `MessageSeverity` with all fields set to `false` expect `verbose`.
     #[inline]
     pub const fn verbose() -> MessageSeverity {
         MessageSeverity {
             verbose: true,
             ..MessageSeverity::none()
         }
     }

     /// Builds a `MessageSeverity` with all fields set to `false` expect `error`, `warning`
     /// and `performance_warning`.
     #[inline]
     pub const fn errors_and_warnings() -> MessageSeverity {
         MessageSeverity {
             error: true,
             warning: true,
             ..MessageSeverity::none()
         }
     }

     /// Builds a `MessageSeverity` with all fields set to `false`.
     #[inline]
     pub const fn none() -> MessageSeverity {
         MessageSeverity {
             error: false,
             warning: false,
             information: false,
             verbose: false,
         }
     }

     /// Builds a `MessageSeverity` with all fields set to `true`.
     #[inline]
     pub const fn all() -> MessageSeverity {
         MessageSeverity {
             error: true,
             warning: true,
             information: true,
             verbose: true,
         }
     }
 }

 impl std::ops::BitOr for MessageSeverity {
     type Output = Self;
     fn bitor(self, rhs: Self) -> Self::Output {
         MessageSeverity {
             error: self.error | rhs.error,
             warning: self.warning | rhs.warning,
             information: self.information | rhs.information,
             verbose: self.verbose | rhs.verbose,
         }
     }
 }

 /// Type of message.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct MessageType {
     /// Specifies that some general event has occurred.
     pub general: bool,
     /// Specifies that something has occurred during validation against the vulkan specification
     pub validation: bool,
     /// Specifies a potentially non-optimal use of Vulkan
     pub performance: bool,
 }

 impl MessageType {
     /// Builds a `MessageType` with general field set to `true`.
     #[inline]
     pub const fn general() -> MessageType {
         MessageType {
             general: true,
             validation: false,
             performance: false,
         }
     }

     /// Builds a `MessageType` with validation field set to `true`.
     #[inline]
     pub const fn validation() -> MessageType {
         MessageType {
             general: false,
             validation: true,
             performance: false,
         }
     }

     /// Builds a `MessageType` with performance field set to `true`.
     #[inline]
     pub const fn performance() -> MessageType {
         MessageType {
             general: false,
             validation: false,
             performance: true,
         }
     }

     /// Builds a `MessageType` with all fields set to `true`.
     #[inline]
     pub const fn all() -> MessageType {
         MessageType {
             general: true,
             validation: true,
             performance: true,
         }
     }

     /// Builds a `MessageType` with all fields set to `false`.
     #[inline]
     pub const fn none() -> MessageType {
         MessageType {
             general: false,
             validation: false,
             performance: false,
         }
     }
 }

 impl std::ops::BitOr for MessageType {
     type Output = Self;
     fn bitor(self, rhs: Self) -> Self::Output {
         MessageType {
             general: self.general | rhs.general,
             validation: self.validation | rhs.validation,
             performance: self.performance | rhs.performance,
         }
     }
 }

 /// Error that can happen when creating a debug callback.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum DebugCallbackCreationError {
     /// The `EXT_debug_utils` extension was not enabled.
     MissingExtension,
 }

 impl error::Error for DebugCallbackCreationError {}

 impl fmt::Display for DebugCallbackCreationError {
     #[inline]
     fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         write!(
             fmt,
             "{}",
             match *self {
                 DebugCallbackCreationError::MissingExtension => {
                     "the `EXT_debug_utils` extension was not enabled"
                 }
             }
         )
     }
 }

 impl From<Error> for DebugCallbackCreationError {
     #[inline]
     fn from(err: Error) -> DebugCallbackCreationError {
         panic!("unexpected error: {:?}", err)
     }
 }

 #[cfg(test)]
 mod tests {
     use super::*;
     use std::thread;
     #[test]
     fn ensure_sendable() {
         // It's useful to be able to initialize a DebugCallback on one thread
         // and keep it alive on another thread.
         let instance = instance!();
         let severity = MessageSeverity::none();
         let ty = MessageType::all();
         let callback = DebugCallback::new(&instance, severity, ty, |_| {});
         thread::spawn(move || {
             let _ = callback;
         });
     }
 }
	// Copyright (c) 2016 The vulkano developers
	// Licensed under the Apache License, Version 2.0
	// <LICENSE-APACHE or
	// https://www.apache.org/licenses/LICENSE-2.0> or the MIT
	// license <LICENSE-MIT or https://opensource.org/licenses/MIT>,
	// at your option. All files in the project carrying such
	// notice may not be copied, modified, or distributed except
	// according to those terms.

	//! Debug callback called by intermediate layers or by the driver.
	//!
	//! When working on an application, it is recommended to register a debug callback. For example if
	//! you enable the validation layers provided by the official Vulkan SDK, they will warn you about
	//! invalid API usages or performance problems by calling this callback. The callback can also
	//! be called by the driver or by whatever intermediate layer is activated.
	//!
	//! Note that the vulkano library can also emit messages to warn you about performance issues.
	//! TODO: ^ that's not the case yet, need to choose whether we keep this idea
	//!
	//! # Example
	//!
	//! ```
	//! # use vulkano::instance::Instance;
	//! # use std::sync::Arc;
	//! # let instance: Arc<Instance> = return;
	//! use vulkano::instance::debug::DebugCallback;
	//!
	//! let _callback = DebugCallback::errors_and_warnings(&instance, \|msg\| {
	//! println!("Debug callback: {:?}", msg.description);
	//! }).ok();
	//! ```
	//!
	//! The type of `msg` in the callback is [`Message`](struct.Message.html).
	//!
	//! Note that you must keep the `_callback` object alive for as long as you want your callback to
	//! be callable. If you don't store the return value of `DebugCallback`'s constructor in a
	//! variable, it will be immediately destroyed and your callback will not work.
	//!

	use crate::check_errors;
	use crate::instance::Instance;
	use crate::Error;
	use crate::VulkanObject;
	use std::error;
	use std::ffi::CStr;
	use std::fmt;
	use std::mem::MaybeUninit;
	use std::os::raw::c_void;
	use std::panic;
	use std::ptr;
	use std::sync::Arc;

	/// Registration of a callback called by validation layers.
	///
	/// The callback can be called as long as this object is alive.
	#[must_use = "The DebugCallback object must be kept alive for as long as you want your callback \
	to be called"]
	pub struct DebugCallback {
	instance: Arc<Instance>,
	debug_report_callback: ash::vk::DebugUtilsMessengerEXT,
	user_callback: Box<Box<dyn Fn(&Message) + Send>>,
	}

	impl DebugCallback {
	/// Initializes a debug callback.
	///
	/// Panics generated by calling `user_callback` are ignored.
	pub fn new<F>(
	instance: &Arc<Instance>,
	severity: MessageSeverity,
	ty: MessageType,
	user_callback: F,
	) -> Result<DebugCallback, DebugCallbackCreationError>
	where
	F: Fn(&Message) + 'static + Send + panic::RefUnwindSafe,
	{
	if !instance.enabled_extensions().ext_debug_utils {
	return Err(DebugCallbackCreationError::MissingExtension);
	}

	// Note that we need to double-box the callback, because a `*const Fn()` is a fat pointer
	// that can't be cast to a `*const c_void`.
	let user_callback = Box::new(Box::new(user_callback) as Box<_>);

	unsafe extern "system" fn callback(
	severity: ash::vk::DebugUtilsMessageSeverityFlagsEXT,
	ty: ash::vk::DebugUtilsMessageTypeFlagsEXT,
	callback_data: *const ash::vk::DebugUtilsMessengerCallbackDataEXT,
	user_data: *mut c_void,
	) -> ash::vk::Bool32 {
	let user_callback = user_data as mut Box<dyn Fn()> as const _;
	let user_callback: &Box<dyn Fn(&Message)> = &*user_callback;

	let layer_prefix = (*callback_data)
	.p_message_id_name
	.as_ref()
	.map(\|msg_id_name\| {
	CStr::from_ptr(msg_id_name)
	.to_str()
	.expect("debug callback message not utf-8")
	});

	let description = CStr::from_ptr((*callback_data).p_message)
	.to_str()
	.expect("debug callback message not utf-8");

	let message = Message {
	severity: MessageSeverity {
	information: !(severity & ash::vk::DebugUtilsMessageSeverityFlagsEXT::INFO)
	.is_empty(),
	warning: !(severity & ash::vk::DebugUtilsMessageSeverityFlagsEXT::WARNING)
	.is_empty(),
	error: !(severity & ash::vk::DebugUtilsMessageSeverityFlagsEXT::ERROR)
	.is_empty(),
	verbose: !(severity & ash::vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE)
	.is_empty(),
	},
	ty: MessageType {
	general: !(ty & ash::vk::DebugUtilsMessageTypeFlagsEXT::GENERAL).is_empty(),
	validation: !(ty & ash::vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION)
	.is_empty(),
	performance: !(ty & ash::vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE)
	.is_empty(),
	},
	layer_prefix,
	description,
	};

	// Since we box the closure, the type system doesn't detect that the `UnwindSafe`
	// bound is enforced. Therefore we enforce it manually.
	let _ = panic::catch_unwind(panic::AssertUnwindSafe(move \|\| {
	user_callback(&message);
	}));

	ash::vk::FALSE
	}

	let severity = {
	let mut flags = ash::vk::DebugUtilsMessageSeverityFlagsEXT::empty();
	if severity.information {
	flags \|= ash::vk::DebugUtilsMessageSeverityFlagsEXT::INFO;
	}
	if severity.warning {
	flags \|= ash::vk::DebugUtilsMessageSeverityFlagsEXT::WARNING;
	}
	if severity.error {
	flags \|= ash::vk::DebugUtilsMessageSeverityFlagsEXT::ERROR;
	}
	if severity.verbose {
	flags \|= ash::vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE;
	}
	flags
	};

	let ty = {
	let mut flags = ash::vk::DebugUtilsMessageTypeFlagsEXT::empty();
	if ty.general {
	flags \|= ash::vk::DebugUtilsMessageTypeFlagsEXT::GENERAL;
	}
	if ty.validation {
	flags \|= ash::vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION;
	}
	if ty.performance {
	flags \|= ash::vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE;
	}
	flags
	};

	let infos = ash::vk::DebugUtilsMessengerCreateInfoEXT {
	flags: ash::vk::DebugUtilsMessengerCreateFlagsEXT::empty(),
	message_severity: severity,
	message_type: ty,
	pfn_user_callback: Some(callback),
	p_user_data: &user_callback as &Box<_> as const Box<_> as const c_void as mut _,
	..Default::default()
	};

	let fns = instance.fns();

	let debug_report_callback = unsafe {
	let mut output = MaybeUninit::uninit();
	check_errors(fns.ext_debug_utils.create_debug_utils_messenger_ext(
	instance.internal_object(),
	&infos,
	ptr::null(),
	output.as_mut_ptr(),
	))?;
	output.assume_init()
	};

	Ok(DebugCallback {
	instance: instance.clone(),
	debug_report_callback,
	user_callback,
	})
	}

	/// Initializes a debug callback with errors and warnings.
	///
	/// Shortcut for `new(instance, MessageTypes::errors_and_warnings(), user_callback)`.
	#[inline]
	pub fn errors_and_warnings<F>(
	instance: &Arc<Instance>,
	user_callback: F,
	) -> Result<DebugCallback, DebugCallbackCreationError>
	where
	F: Fn(&Message) + Send + 'static + panic::RefUnwindSafe,
	{
	DebugCallback::new(
	instance,
	MessageSeverity::errors_and_warnings(),
	MessageType::general(),
	user_callback,
	)
	}
	}

	impl Drop for DebugCallback {
	#[inline]
	fn drop(&mut self) {
	unsafe {
	let fns = self.instance.fns();
	fns.ext_debug_utils.destroy_debug_utils_messenger_ext(
	self.instance.internal_object(),
	self.debug_report_callback,
	ptr::null(),
	);
	}
	}
	}

	/// A message received by the callback.
	pub struct Message<'a> {
	/// Severity of message.
	pub severity: MessageSeverity,
	/// Type of message,
	pub ty: MessageType,
	/// Prefix of the layer that reported this message or `None` if unknown.
	pub layer_prefix: Option<&'a str>,
	/// Description of the message.
	pub description: &'a str,
	}

	/// Severity of message.
	#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
	pub struct MessageSeverity {
	/// An error that may cause undefined results, including an application crash.
	pub error: bool,
	/// An unexpected use.
	pub warning: bool,
	/// An informational message that may be handy when debugging an application.
	pub information: bool,
	/// Diagnostic information from the loader and layers.
	pub verbose: bool,
	}

	impl MessageSeverity {
	/// Builds a `MessageSeverity` with all fields set to `false` expect `error`.
	#[inline]
	pub const fn errors() -> MessageSeverity {
	MessageSeverity {
	error: true,
	..MessageSeverity::none()
	}
	}

	/// Builds a `MessageSeverity` with all fields set to `false` expect `warning`.
	#[inline]
	pub const fn warnings() -> MessageSeverity {
	MessageSeverity {
	warning: true,
	..MessageSeverity::none()
	}
	}

	/// Builds a `MessageSeverity` with all fields set to `false` expect `information`.
	#[inline]
	pub const fn information() -> MessageSeverity {
	MessageSeverity {
	information: true,
	..MessageSeverity::none()
	}
	}

	/// Builds a `MessageSeverity` with all fields set to `false` expect `verbose`.
	#[inline]
	pub const fn verbose() -> MessageSeverity {
	MessageSeverity {
	verbose: true,
	..MessageSeverity::none()
	}
	}

	/// Builds a `MessageSeverity` with all fields set to `false` expect `error`, `warning`
	/// and `performance_warning`.
	#[inline]
	pub const fn errors_and_warnings() -> MessageSeverity {
	MessageSeverity {
	error: true,
	warning: true,
	..MessageSeverity::none()
	}
	}

	/// Builds a `MessageSeverity` with all fields set to `false`.
	#[inline]
	pub const fn none() -> MessageSeverity {
	MessageSeverity {
	error: false,
	warning: false,
	information: false,
	verbose: false,
	}
	}

	/// Builds a `MessageSeverity` with all fields set to `true`.
	#[inline]
	pub const fn all() -> MessageSeverity {
	MessageSeverity {
	error: true,
	warning: true,
	information: true,
	verbose: true,
	}
	}
	}

	impl std::ops::BitOr for MessageSeverity {
	type Output = Self;
	fn bitor(self, rhs: Self) -> Self::Output {
	MessageSeverity {
	error: self.error \| rhs.error,
	warning: self.warning \| rhs.warning,
	information: self.information \| rhs.information,
	verbose: self.verbose \| rhs.verbose,
	}
	}
	}

	/// Type of message.
	#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
	pub struct MessageType {
	/// Specifies that some general event has occurred.
	pub general: bool,
	/// Specifies that something has occurred during validation against the vulkan specification
	pub validation: bool,
	/// Specifies a potentially non-optimal use of Vulkan
	pub performance: bool,
	}

	impl MessageType {
	/// Builds a `MessageType` with general field set to `true`.
	#[inline]
	pub const fn general() -> MessageType {
	MessageType {
	general: true,
	validation: false,
	performance: false,
	}
	}

	/// Builds a `MessageType` with validation field set to `true`.
	#[inline]
	pub const fn validation() -> MessageType {
	MessageType {
	general: false,
	validation: true,
	performance: false,
	}
	}

	/// Builds a `MessageType` with performance field set to `true`.
	#[inline]
	pub const fn performance() -> MessageType {
	MessageType {
	general: false,
	validation: false,
	performance: true,
	}
	}

	/// Builds a `MessageType` with all fields set to `true`.
	#[inline]
	pub const fn all() -> MessageType {
	MessageType {
	general: true,
	validation: true,
	performance: true,
	}
	}

	/// Builds a `MessageType` with all fields set to `false`.
	#[inline]
	pub const fn none() -> MessageType {
	MessageType {
	general: false,
	validation: false,
	performance: false,
	}
	}
	}

	impl std::ops::BitOr for MessageType {
	type Output = Self;
	fn bitor(self, rhs: Self) -> Self::Output {
	MessageType {
	general: self.general \| rhs.general,
	validation: self.validation \| rhs.validation,
	performance: self.performance \| rhs.performance,
	}
	}
	}

	/// Error that can happen when creating a debug callback.
	#[derive(Copy, Clone, Debug, PartialEq, Eq)]
	pub enum DebugCallbackCreationError {
	/// The `EXT_debug_utils` extension was not enabled.
	MissingExtension,
	}

	impl error::Error for DebugCallbackCreationError {}

	impl fmt::Display for DebugCallbackCreationError {
	#[inline]
	fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
	write!(
	fmt,
	"{}",
	match *self {
	DebugCallbackCreationError::MissingExtension => {
	"the `EXT_debug_utils` extension was not enabled"
	}
	}
	)
	}
	}

	impl From<Error> for DebugCallbackCreationError {
	#[inline]
	fn from(err: Error) -> DebugCallbackCreationError {
	panic!("unexpected error: {:?}", err)
	}
	}

	#[cfg(test)]
	mod tests {
	use super::*;
	use std::thread;
	#[test]
	fn ensure_sendable() {
	// It's useful to be able to initialize a DebugCallback on one thread
	// and keep it alive on another thread.
	let instance = instance!();
	let severity = MessageSeverity::none();
	let ty = MessageType::all();
	let callback = DebugCallback::new(&instance, severity, ty, \|_\| {});
	thread::spawn(move \|\| {
	let _ = callback;
	});
	}
	}