#![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_device_generated_commands_compute";
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 ComputePipelineIndirectBufferInfoNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub device_address: DeviceAddress,
pub size: DeviceSize,
pub pipeline_device_address_capture_replay: DeviceAddress,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for ComputePipelineIndirectBufferInfoNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ComputePipelineIndirectBufferInfoNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("device_address", &self.device_address)
.field("size", &self.size)
.field(
"pipeline_device_address_capture_replay",
&self.pipeline_device_address_capture_replay,
)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for ComputePipelineIndirectBufferInfoNV<'a> {
const STRUCTURE_TYPE: StructureType =
StructureType::COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV;
}
unsafe impl Extends<ComputePipelineCreateInfo<'_>> for ComputePipelineIndirectBufferInfoNV<'_> {}
impl Default for ComputePipelineIndirectBufferInfoNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
device_address: Default::default(),
size: Default::default(),
pipeline_device_address_capture_replay: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> ComputePipelineIndirectBufferInfoNV<'a> {
#[inline]
pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
self.device_address = device_address;
self
}
#[inline]
pub fn size(mut self, size: DeviceSize) -> Self {
self.size = size;
self
}
#[inline]
pub fn pipeline_device_address_capture_replay(
mut self,
pipeline_device_address_capture_replay: DeviceAddress,
) -> Self {
self.pipeline_device_address_capture_replay = pipeline_device_address_capture_replay;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub device_generated_compute: Bool32,
pub device_generated_compute_pipelines: Bool32,
pub device_generated_compute_capture_replay: Bool32,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("device_generated_compute", &self.device_generated_compute)
.field(
"device_generated_compute_pipelines",
&self.device_generated_compute_pipelines,
)
.field(
"device_generated_compute_capture_replay",
&self.device_generated_compute_capture_replay,
)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> {
const STRUCTURE_TYPE: StructureType =
StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
}
unsafe impl Extends<PhysicalDeviceFeatures2<'_>>
for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_>
{
}
unsafe impl Extends<DeviceCreateInfo<'_>>
for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_>
{
}
impl Default for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
device_generated_compute: Default::default(),
device_generated_compute_pipelines: Default::default(),
device_generated_compute_capture_replay: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> {
#[inline]
pub fn device_generated_compute(mut self, device_generated_compute: bool) -> Self {
self.device_generated_compute = device_generated_compute.into();
self
}
#[inline]
pub fn device_generated_compute_pipelines(
mut self,
device_generated_compute_pipelines: bool,
) -> Self {
self.device_generated_compute_pipelines = device_generated_compute_pipelines.into();
self
}
#[inline]
pub fn device_generated_compute_capture_replay(
mut self,
device_generated_compute_capture_replay: bool,
) -> Self {
self.device_generated_compute_capture_replay =
device_generated_compute_capture_replay.into();
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct PipelineIndirectDeviceAddressInfoNV<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub pipeline_bind_point: PipelineBindPoint,
pub pipeline: Pipeline,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for PipelineIndirectDeviceAddressInfoNV<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PipelineIndirectDeviceAddressInfoNV")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("pipeline_bind_point", &self.pipeline_bind_point)
.field("pipeline", &self.pipeline)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for PipelineIndirectDeviceAddressInfoNV<'a> {
const STRUCTURE_TYPE: StructureType =
StructureType::PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV;
}
impl Default for PipelineIndirectDeviceAddressInfoNV<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
pipeline_bind_point: Default::default(),
pipeline: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> PipelineIndirectDeviceAddressInfoNV<'a> {
#[inline]
pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
self.pipeline_bind_point = pipeline_bind_point;
self
}
#[inline]
pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
self.pipeline = pipeline;
self
}
}
#[repr(C)]
#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Copy, Clone, Default)]
#[must_use]
pub struct BindPipelineIndirectCommandNV {
pub pipeline_address: DeviceAddress,
}
impl BindPipelineIndirectCommandNV {
#[inline]
pub fn pipeline_address(mut self, pipeline_address: DeviceAddress) -> Self {
self.pipeline_address = pipeline_address;
self
}
}
pub type PFN_vkCmdUpdatePipelineIndirectBufferNV = unsafe extern "system" fn(
command_buffer: CommandBuffer,
pipeline_bind_point: PipelineBindPoint,
pipeline: Pipeline,
);
pub type PFN_vkGetPipelineIndirectMemoryRequirementsNV = unsafe extern "system" fn(
device: Device,
p_create_info: *const ComputePipelineCreateInfo<'_>,
p_memory_requirements: *mut MemoryRequirements2<'_>,
);
pub type PFN_vkGetPipelineIndirectDeviceAddressNV = unsafe extern "system" fn(
device: Device,
p_info: *const PipelineIndirectDeviceAddressInfoNV<'_>,
)
-> DeviceAddress;
}
#[cfg(feature = "ffi")]
pub(super) mod ffi {
#![allow(non_camel_case_types)]
use super::defs::*;
pub type VkComputePipelineIndirectBufferInfoNV = ComputePipelineIndirectBufferInfoNV<'static>;
pub type VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV =
PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'static>;
pub type VkPipelineIndirectDeviceAddressInfoNV = PipelineIndirectDeviceAddressInfoNV<'static>;
pub type VkBindPipelineIndirectCommandNV = BindPipelineIndirectCommandNV;
impl ComputePipelineIndirectBufferInfoNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkComputePipelineIndirectBufferInfoNV {
unsafe { core::mem::transmute(self) }
}
}
impl PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(
&self,
) -> &VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
unsafe { core::mem::transmute(self) }
}
}
impl PipelineIndirectDeviceAddressInfoNV<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPipelineIndirectDeviceAddressInfoNV {
unsafe { core::mem::transmute(self) }
}
}
}
pub struct DeviceFn {
get_pipeline_indirect_memory_requirements: PFN_vkGetPipelineIndirectMemoryRequirementsNV,
cmd_update_pipeline_indirect_buffer: PFN_vkCmdUpdatePipelineIndirectBufferNV,
get_pipeline_indirect_device_address: PFN_vkGetPipelineIndirectDeviceAddressNV,
}
impl LoadDeviceFn for DeviceFn {
unsafe fn load_with(
load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
) -> core::result::Result<Self, MissingEntryPointError> {
unsafe {
Ok(Self {
get_pipeline_indirect_memory_requirements: transmute(
load(c"vkGetPipelineIndirectMemoryRequirementsNV")
.ok_or(MissingEntryPointError)?,
),
cmd_update_pipeline_indirect_buffer: transmute(
load(c"vkCmdUpdatePipelineIndirectBufferNV").ok_or(MissingEntryPointError)?,
),
get_pipeline_indirect_device_address: transmute(
load(c"vkGetPipelineIndirectDeviceAddressNV").ok_or(MissingEntryPointError)?,
),
})
}
}
}
impl DeviceFn {
#[inline]
pub unsafe fn get_pipeline_indirect_memory_requirements(
&self,
device: Device,
create_info: &ComputePipelineCreateInfo<'_>,
memory_requirements: &mut MemoryRequirements2<'_>,
) {
unsafe {
(self.get_pipeline_indirect_memory_requirements)(
device,
create_info,
memory_requirements,
)
}
}
#[inline]
pub unsafe fn cmd_update_pipeline_indirect_buffer(
&self,
command_buffer: CommandBuffer,
pipeline_bind_point: PipelineBindPoint,
pipeline: Pipeline,
) {
unsafe {
(self.cmd_update_pipeline_indirect_buffer)(
command_buffer,
pipeline_bind_point,
pipeline,
)
}
}
#[inline]
pub unsafe fn get_pipeline_indirect_device_address(
&self,
device: Device,
info: &PipelineIndirectDeviceAddressInfoNV<'_>,
) -> DeviceAddress {
unsafe { (self.get_pipeline_indirect_device_address)(device, info) }
}
}