#![allow(unused_imports)]
use crate::{vk::Result as VkResult, vk::*, *};
use core::ffi::{CStr, c_char, c_int, c_void};
use core::mem::transmute;
use core::ptr;
pub const EXTENSION_NAME: &CStr = c"VK_NV_low_latency2";
pub(super) mod defs {
#![allow(non_camel_case_types, unused_imports)]
use crate::{vk::*, *};
use core::ffi::{CStr, c_char, c_int, c_void};
use core::fmt;
use core::marker::PhantomData;
use core::ptr;
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct LatencySleepModeInfoNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub low_latency_mode: Bool32,
pub low_latency_boost: Bool32,
pub minimum_interval_us: u32,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for LatencySleepModeInfoNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("LatencySleepModeInfoNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("low_latency_mode", &self.low_latency_mode)
.field("low_latency_boost", &self.low_latency_boost)
.field("minimum_interval_us", &self.minimum_interval_us)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for LatencySleepModeInfoNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_SLEEP_MODE_INFO_NV;
}
impl Default for LatencySleepModeInfoNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
low_latency_mode: Default::default(),
low_latency_boost: Default::default(),
minimum_interval_us: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> LatencySleepModeInfoNV<'a> {
#[inline]
pub fn low_latency_mode(mut self, low_latency_mode: bool) -> Self {
self.low_latency_mode = low_latency_mode.into();
self
}
#[inline]
pub fn low_latency_boost(mut self, low_latency_boost: bool) -> Self {
self.low_latency_boost = low_latency_boost.into();
self
}
#[inline]
pub fn minimum_interval_us(mut self, minimum_interval_us: u32) -> Self {
self.minimum_interval_us = minimum_interval_us;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct LatencySleepInfoNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub signal_semaphore: Semaphore,
pub value: u64,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for LatencySleepInfoNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("LatencySleepInfoNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("signal_semaphore", &self.signal_semaphore)
.field("value", &self.value)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for LatencySleepInfoNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_SLEEP_INFO_NV;
}
impl Default for LatencySleepInfoNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
signal_semaphore: Default::default(),
value: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> LatencySleepInfoNV<'a> {
#[inline]
pub fn signal_semaphore(mut self, signal_semaphore: Semaphore) -> Self {
self.signal_semaphore = signal_semaphore;
self
}
#[inline]
pub fn value(mut self, value: u64) -> Self {
self.value = value;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct SetLatencyMarkerInfoNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub present_id: u64,
pub marker: LatencyMarkerNV,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for SetLatencyMarkerInfoNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SetLatencyMarkerInfoNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("present_id", &self.present_id)
.field("marker", &self.marker)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for SetLatencyMarkerInfoNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::SET_LATENCY_MARKER_INFO_NV;
}
impl Default for SetLatencyMarkerInfoNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
present_id: Default::default(),
marker: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> SetLatencyMarkerInfoNV<'a> {
#[inline]
pub fn present_id(mut self, present_id: u64) -> Self {
self.present_id = present_id;
self
}
#[inline]
pub fn marker(mut self, marker: LatencyMarkerNV) -> Self {
self.marker = marker;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct GetLatencyMarkerInfoNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub timing_count: u32,
pub p_timings: *mut LatencyTimingsFrameReportNV<'a>,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for GetLatencyMarkerInfoNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("GetLatencyMarkerInfoNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("timing_count", &self.timing_count)
.field("p_timings", &self.p_timings)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for GetLatencyMarkerInfoNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::GET_LATENCY_MARKER_INFO_NV;
}
impl Default for GetLatencyMarkerInfoNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
timing_count: Default::default(),
p_timings: ptr::null_mut(),
_marker: PhantomData,
}
}
}
impl<'a> GetLatencyMarkerInfoNV<'a> {
#[inline]
pub fn timings(mut self, timings: &'a mut [LatencyTimingsFrameReportNV<'_>]) -> Self {
self.timing_count = timings.len().try_into().unwrap();
self.p_timings = timings.as_mut_ptr() as _;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct LatencyTimingsFrameReportNV<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub present_id: u64,
pub input_sample_time_us: u64,
pub sim_start_time_us: u64,
pub sim_end_time_us: u64,
pub render_submit_start_time_us: u64,
pub render_submit_end_time_us: u64,
pub present_start_time_us: u64,
pub present_end_time_us: u64,
pub driver_start_time_us: u64,
pub driver_end_time_us: u64,
pub os_render_queue_start_time_us: u64,
pub os_render_queue_end_time_us: u64,
pub gpu_render_start_time_us: u64,
pub gpu_render_end_time_us: u64,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for LatencyTimingsFrameReportNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("LatencyTimingsFrameReportNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("present_id", &self.present_id)
.field("input_sample_time_us", &self.input_sample_time_us)
.field("sim_start_time_us", &self.sim_start_time_us)
.field("sim_end_time_us", &self.sim_end_time_us)
.field(
"render_submit_start_time_us",
&self.render_submit_start_time_us,
)
.field("render_submit_end_time_us", &self.render_submit_end_time_us)
.field("present_start_time_us", &self.present_start_time_us)
.field("present_end_time_us", &self.present_end_time_us)
.field("driver_start_time_us", &self.driver_start_time_us)
.field("driver_end_time_us", &self.driver_end_time_us)
.field(
"os_render_queue_start_time_us",
&self.os_render_queue_start_time_us,
)
.field(
"os_render_queue_end_time_us",
&self.os_render_queue_end_time_us,
)
.field("gpu_render_start_time_us", &self.gpu_render_start_time_us)
.field("gpu_render_end_time_us", &self.gpu_render_end_time_us)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for LatencyTimingsFrameReportNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_TIMINGS_FRAME_REPORT_NV;
}
impl Default for LatencyTimingsFrameReportNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
present_id: Default::default(),
input_sample_time_us: Default::default(),
sim_start_time_us: Default::default(),
sim_end_time_us: Default::default(),
render_submit_start_time_us: Default::default(),
render_submit_end_time_us: Default::default(),
present_start_time_us: Default::default(),
present_end_time_us: Default::default(),
driver_start_time_us: Default::default(),
driver_end_time_us: Default::default(),
os_render_queue_start_time_us: Default::default(),
os_render_queue_end_time_us: Default::default(),
gpu_render_start_time_us: Default::default(),
gpu_render_end_time_us: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> LatencyTimingsFrameReportNV<'a> {
#[inline]
pub fn present_id(mut self, present_id: u64) -> Self {
self.present_id = present_id;
self
}
#[inline]
pub fn input_sample_time_us(mut self, input_sample_time_us: u64) -> Self {
self.input_sample_time_us = input_sample_time_us;
self
}
#[inline]
pub fn sim_start_time_us(mut self, sim_start_time_us: u64) -> Self {
self.sim_start_time_us = sim_start_time_us;
self
}
#[inline]
pub fn sim_end_time_us(mut self, sim_end_time_us: u64) -> Self {
self.sim_end_time_us = sim_end_time_us;
self
}
#[inline]
pub fn render_submit_start_time_us(mut self, render_submit_start_time_us: u64) -> Self {
self.render_submit_start_time_us = render_submit_start_time_us;
self
}
#[inline]
pub fn render_submit_end_time_us(mut self, render_submit_end_time_us: u64) -> Self {
self.render_submit_end_time_us = render_submit_end_time_us;
self
}
#[inline]
pub fn present_start_time_us(mut self, present_start_time_us: u64) -> Self {
self.present_start_time_us = present_start_time_us;
self
}
#[inline]
pub fn present_end_time_us(mut self, present_end_time_us: u64) -> Self {
self.present_end_time_us = present_end_time_us;
self
}
#[inline]
pub fn driver_start_time_us(mut self, driver_start_time_us: u64) -> Self {
self.driver_start_time_us = driver_start_time_us;
self
}
#[inline]
pub fn driver_end_time_us(mut self, driver_end_time_us: u64) -> Self {
self.driver_end_time_us = driver_end_time_us;
self
}
#[inline]
pub fn os_render_queue_start_time_us(mut self, os_render_queue_start_time_us: u64) -> Self {
self.os_render_queue_start_time_us = os_render_queue_start_time_us;
self
}
#[inline]
pub fn os_render_queue_end_time_us(mut self, os_render_queue_end_time_us: u64) -> Self {
self.os_render_queue_end_time_us = os_render_queue_end_time_us;
self
}
#[inline]
pub fn gpu_render_start_time_us(mut self, gpu_render_start_time_us: u64) -> Self {
self.gpu_render_start_time_us = gpu_render_start_time_us;
self
}
#[inline]
pub fn gpu_render_end_time_us(mut self, gpu_render_end_time_us: u64) -> Self {
self.gpu_render_end_time_us = gpu_render_end_time_us;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct OutOfBandQueueTypeInfoNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub queue_type: OutOfBandQueueTypeNV,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for OutOfBandQueueTypeInfoNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("OutOfBandQueueTypeInfoNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("queue_type", &self.queue_type)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for OutOfBandQueueTypeInfoNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::OUT_OF_BAND_QUEUE_TYPE_INFO_NV;
}
impl Default for OutOfBandQueueTypeInfoNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
queue_type: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> OutOfBandQueueTypeInfoNV<'a> {
#[inline]
pub fn queue_type(mut self, queue_type: OutOfBandQueueTypeNV) -> Self {
self.queue_type = queue_type;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct LatencySubmissionPresentIdNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub present_id: u64,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for LatencySubmissionPresentIdNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("LatencySubmissionPresentIdNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("present_id", &self.present_id)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for LatencySubmissionPresentIdNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_SUBMISSION_PRESENT_ID_NV;
}
unsafe impl Extends<SubmitInfo<'_>> for LatencySubmissionPresentIdNV<'_> {}
unsafe impl Extends<SubmitInfo2<'_>> for LatencySubmissionPresentIdNV<'_> {}
impl Default for LatencySubmissionPresentIdNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
present_id: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> LatencySubmissionPresentIdNV<'a> {
#[inline]
pub fn present_id(mut self, present_id: u64) -> Self {
self.present_id = present_id;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct SwapchainLatencyCreateInfoNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub latency_mode_enable: Bool32,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for SwapchainLatencyCreateInfoNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SwapchainLatencyCreateInfoNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("latency_mode_enable", &self.latency_mode_enable)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for SwapchainLatencyCreateInfoNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_LATENCY_CREATE_INFO_NV;
}
unsafe impl Extends<SwapchainCreateInfoKHR<'_>> for SwapchainLatencyCreateInfoNV<'_> {}
impl Default for SwapchainLatencyCreateInfoNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
latency_mode_enable: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> SwapchainLatencyCreateInfoNV<'a> {
#[inline]
pub fn latency_mode_enable(mut self, latency_mode_enable: bool) -> Self {
self.latency_mode_enable = latency_mode_enable.into();
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct LatencySurfaceCapabilitiesNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub present_mode_count: u32,
pub p_present_modes: *mut PresentModeKHR,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for LatencySurfaceCapabilitiesNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("LatencySurfaceCapabilitiesNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("present_mode_count", &self.present_mode_count)
.field("p_present_modes", &self.p_present_modes)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for LatencySurfaceCapabilitiesNV<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_SURFACE_CAPABILITIES_NV;
}
unsafe impl Extends<SurfaceCapabilities2KHR<'_>> for LatencySurfaceCapabilitiesNV<'_> {}
impl Default for LatencySurfaceCapabilitiesNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
present_mode_count: Default::default(),
p_present_modes: ptr::null_mut(),
_marker: PhantomData,
}
}
}
impl<'a> LatencySurfaceCapabilitiesNV<'a> {
#[inline]
pub fn present_modes(mut self, present_modes: &'a mut [PresentModeKHR]) -> Self {
self.present_mode_count = present_modes.len().try_into().unwrap();
self.p_present_modes = present_modes.as_mut_ptr() as _;
self
}
}
#[repr(transparent)]
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct LatencyMarkerNV(i32);
impl LatencyMarkerNV {
#[inline]
pub const fn from_raw(x: i32) -> Self {
Self(x)
}
#[inline]
pub const fn as_raw(self) -> i32 {
self.0
}
pub const SIMULATION_START_NV: Self = Self(0);
pub const SIMULATION_END_NV: Self = Self(1);
pub const RENDERSUBMIT_START_NV: Self = Self(2);
pub const RENDERSUBMIT_END_NV: Self = Self(3);
pub const PRESENT_START_NV: Self = Self(4);
pub const PRESENT_END_NV: Self = Self(5);
pub const INPUT_SAMPLE_NV: Self = Self(6);
pub const TRIGGER_FLASH_NV: Self = Self(7);
pub const OUT_OF_BAND_RENDERSUBMIT_START_NV: Self = Self(8);
pub const OUT_OF_BAND_RENDERSUBMIT_END_NV: Self = Self(9);
pub const OUT_OF_BAND_PRESENT_START_NV: Self = Self(10);
pub const OUT_OF_BAND_PRESENT_END_NV: Self = Self(11);
}
impl fmt::Debug for LatencyMarkerNV {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = match *self {
Self::SIMULATION_START_NV => Some("SIMULATION_START_NV"),
Self::SIMULATION_END_NV => Some("SIMULATION_END_NV"),
Self::RENDERSUBMIT_START_NV => Some("RENDERSUBMIT_START_NV"),
Self::RENDERSUBMIT_END_NV => Some("RENDERSUBMIT_END_NV"),
Self::PRESENT_START_NV => Some("PRESENT_START_NV"),
Self::PRESENT_END_NV => Some("PRESENT_END_NV"),
Self::INPUT_SAMPLE_NV => Some("INPUT_SAMPLE_NV"),
Self::TRIGGER_FLASH_NV => Some("TRIGGER_FLASH_NV"),
Self::OUT_OF_BAND_RENDERSUBMIT_START_NV => {
Some("OUT_OF_BAND_RENDERSUBMIT_START_NV")
}
Self::OUT_OF_BAND_RENDERSUBMIT_END_NV => Some("OUT_OF_BAND_RENDERSUBMIT_END_NV"),
Self::OUT_OF_BAND_PRESENT_START_NV => Some("OUT_OF_BAND_PRESENT_START_NV"),
Self::OUT_OF_BAND_PRESENT_END_NV => Some("OUT_OF_BAND_PRESENT_END_NV"),
_ => None,
};
if let Some(name) = name {
f.write_str(name)
} else {
self.0.fmt(f)
}
}
}
#[repr(transparent)]
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct OutOfBandQueueTypeNV(i32);
impl OutOfBandQueueTypeNV {
#[inline]
pub const fn from_raw(x: i32) -> Self {
Self(x)
}
#[inline]
pub const fn as_raw(self) -> i32 {
self.0
}
pub const RENDER_NV: Self = Self(0);
pub const PRESENT_NV: Self = Self(1);
}
impl fmt::Debug for OutOfBandQueueTypeNV {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = match *self {
Self::RENDER_NV => Some("RENDER_NV"),
Self::PRESENT_NV => Some("PRESENT_NV"),
_ => None,
};
if let Some(name) = name {
f.write_str(name)
} else {
self.0.fmt(f)
}
}
}
pub type PFN_vkSetLatencySleepModeNV = unsafe extern "system" fn(
device: Device,
swapchain: SwapchainKHR,
p_sleep_mode_info: *const LatencySleepModeInfoNV<'_>,
) -> vk::Result;
pub type PFN_vkLatencySleepNV = unsafe extern "system" fn(
device: Device,
swapchain: SwapchainKHR,
p_sleep_info: *const LatencySleepInfoNV<'_>,
) -> vk::Result;
pub type PFN_vkSetLatencyMarkerNV = unsafe extern "system" fn(
device: Device,
swapchain: SwapchainKHR,
p_latency_marker_info: *const SetLatencyMarkerInfoNV<'_>,
);
pub type PFN_vkGetLatencyTimingsNV = unsafe extern "system" fn(
device: Device,
swapchain: SwapchainKHR,
p_latency_marker_info: *mut GetLatencyMarkerInfoNV<'_>,
);
pub type PFN_vkQueueNotifyOutOfBandNV = unsafe extern "system" fn(
queue: Queue,
p_queue_type_info: *const OutOfBandQueueTypeInfoNV<'_>,
);
}
#[cfg(feature = "ffi")]
pub(super) mod ffi {
#![allow(non_camel_case_types)]
use super::defs::*;
pub type VkLatencySleepModeInfoNV = LatencySleepModeInfoNV<'static>;
pub type VkLatencySleepInfoNV = LatencySleepInfoNV<'static>;
pub type VkSetLatencyMarkerInfoNV = SetLatencyMarkerInfoNV<'static>;
pub type VkGetLatencyMarkerInfoNV = GetLatencyMarkerInfoNV<'static>;
pub type VkLatencyTimingsFrameReportNV = LatencyTimingsFrameReportNV<'static>;
pub type VkOutOfBandQueueTypeInfoNV = OutOfBandQueueTypeInfoNV<'static>;
pub type VkLatencySubmissionPresentIdNV = LatencySubmissionPresentIdNV<'static>;
pub type VkSwapchainLatencyCreateInfoNV = SwapchainLatencyCreateInfoNV<'static>;
pub type VkLatencySurfaceCapabilitiesNV = LatencySurfaceCapabilitiesNV<'static>;
pub type VkLatencyMarkerNV = LatencyMarkerNV;
pub type VkOutOfBandQueueTypeNV = OutOfBandQueueTypeNV;
impl LatencySleepModeInfoNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkLatencySleepModeInfoNV {
unsafe { core::mem::transmute(self) }
}
}
impl LatencySleepInfoNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkLatencySleepInfoNV {
unsafe { core::mem::transmute(self) }
}
}
impl SetLatencyMarkerInfoNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSetLatencyMarkerInfoNV {
unsafe { core::mem::transmute(self) }
}
}
impl GetLatencyMarkerInfoNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkGetLatencyMarkerInfoNV {
unsafe { core::mem::transmute(self) }
}
}
impl LatencyTimingsFrameReportNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkLatencyTimingsFrameReportNV {
unsafe { core::mem::transmute(self) }
}
}
impl OutOfBandQueueTypeInfoNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkOutOfBandQueueTypeInfoNV {
unsafe { core::mem::transmute(self) }
}
}
impl LatencySubmissionPresentIdNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkLatencySubmissionPresentIdNV {
unsafe { core::mem::transmute(self) }
}
}
impl SwapchainLatencyCreateInfoNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSwapchainLatencyCreateInfoNV {
unsafe { core::mem::transmute(self) }
}
}
impl LatencySurfaceCapabilitiesNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkLatencySurfaceCapabilitiesNV {
unsafe { core::mem::transmute(self) }
}
}
}
pub struct DeviceFn {
set_latency_sleep_mode: PFN_vkSetLatencySleepModeNV,
latency_sleep: PFN_vkLatencySleepNV,
set_latency_marker: PFN_vkSetLatencyMarkerNV,
get_latency_timings: PFN_vkGetLatencyTimingsNV,
queue_notify_out_of_band: PFN_vkQueueNotifyOutOfBandNV,
}
impl LoadDeviceFn for DeviceFn {
unsafe fn load_with(
load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
) -> core::result::Result<Self, MissingEntryPointError> {
unsafe {
Ok(Self {
set_latency_sleep_mode: transmute(
load(c"vkSetLatencySleepModeNV").ok_or(MissingEntryPointError)?,
),
latency_sleep: transmute(load(c"vkLatencySleepNV").ok_or(MissingEntryPointError)?),
set_latency_marker: transmute(
load(c"vkSetLatencyMarkerNV").ok_or(MissingEntryPointError)?,
),
get_latency_timings: transmute(
load(c"vkGetLatencyTimingsNV").ok_or(MissingEntryPointError)?,
),
queue_notify_out_of_band: transmute(
load(c"vkQueueNotifyOutOfBandNV").ok_or(MissingEntryPointError)?,
),
})
}
}
}
impl DeviceFn {
#[inline]
pub unsafe fn set_latency_sleep_mode(
&self,
device: Device,
swapchain: SwapchainKHR,
sleep_mode_info: &LatencySleepModeInfoNV<'_>,
) -> crate::Result<()> {
unsafe {
let result = (self.set_latency_sleep_mode)(device, swapchain, sleep_mode_info);
match result {
VkResult::SUCCESS => Ok(()),
err => Err(err),
}
}
}
#[inline]
pub unsafe fn latency_sleep(
&self,
device: Device,
swapchain: SwapchainKHR,
sleep_info: &LatencySleepInfoNV<'_>,
) -> crate::Result<()> {
unsafe {
let result = (self.latency_sleep)(device, swapchain, sleep_info);
match result {
VkResult::SUCCESS => Ok(()),
err => Err(err),
}
}
}
#[inline]
pub unsafe fn set_latency_marker(
&self,
device: Device,
swapchain: SwapchainKHR,
latency_marker_info: &SetLatencyMarkerInfoNV<'_>,
) {
unsafe { (self.set_latency_marker)(device, swapchain, latency_marker_info) }
}
#[inline]
pub unsafe fn get_latency_timings(
&self,
device: Device,
swapchain: SwapchainKHR,
latency_marker_info: &mut GetLatencyMarkerInfoNV<'_>,
) {
unsafe { (self.get_latency_timings)(device, swapchain, latency_marker_info) }
}
#[inline]
pub unsafe fn queue_notify_out_of_band(
&self,
queue: Queue,
queue_type_info: &OutOfBandQueueTypeInfoNV<'_>,
) {
unsafe { (self.queue_notify_out_of_band)(queue, queue_type_info) }
}
}