#![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_EXT_shader_object";
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;
handle_nondispatchable!(
ShaderEXT,
SHADER_EXT,
doc = "<https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderEXT.html>"
);
pub type ShaderRequiredSubgroupSizeCreateInfoEXT<'a> =
PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct PhysicalDeviceShaderObjectFeaturesEXT<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub shader_object: Bool32,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for PhysicalDeviceShaderObjectFeaturesEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PhysicalDeviceShaderObjectFeaturesEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("shader_object", &self.shader_object)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderObjectFeaturesEXT<'a> {
const STRUCTURE_TYPE: StructureType =
StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
}
unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceShaderObjectFeaturesEXT<'_> {}
unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceShaderObjectFeaturesEXT<'_> {}
impl Default for PhysicalDeviceShaderObjectFeaturesEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
shader_object: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> PhysicalDeviceShaderObjectFeaturesEXT<'a> {
#[inline]
pub fn shader_object(mut self, shader_object: bool) -> Self {
self.shader_object = shader_object.into();
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct PhysicalDeviceShaderObjectPropertiesEXT<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub shader_binary_uuid: [u8; UUID_SIZE as usize],
pub shader_binary_version: u32,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for PhysicalDeviceShaderObjectPropertiesEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PhysicalDeviceShaderObjectPropertiesEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("shader_binary_uuid", &self.shader_binary_uuid)
.field("shader_binary_version", &self.shader_binary_version)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderObjectPropertiesEXT<'a> {
const STRUCTURE_TYPE: StructureType =
StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
}
unsafe impl Extends<PhysicalDeviceProperties2<'_>> for PhysicalDeviceShaderObjectPropertiesEXT<'_> {}
impl Default for PhysicalDeviceShaderObjectPropertiesEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
shader_binary_uuid: [Default::default(); _],
shader_binary_version: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> PhysicalDeviceShaderObjectPropertiesEXT<'a> {
#[inline]
pub fn shader_binary_uuid(mut self, shader_binary_uuid: [u8; UUID_SIZE as usize]) -> Self {
self.shader_binary_uuid = shader_binary_uuid;
self
}
#[inline]
pub fn shader_binary_version(mut self, shader_binary_version: u32) -> Self {
self.shader_binary_version = shader_binary_version;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct ShaderCreateInfoEXT<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub flags: ShaderCreateFlagsEXT,
pub stage: ShaderStageFlagBits,
pub next_stage: ShaderStageFlags,
pub code_type: ShaderCodeTypeEXT,
pub code_size: usize,
pub p_code: *const c_void,
pub p_name: *const c_char,
pub set_layout_count: u32,
pub p_set_layouts: *const DescriptorSetLayout,
pub push_constant_range_count: u32,
pub p_push_constant_ranges: *const PushConstantRange,
pub p_specialization_info: *const SpecializationInfo<'a>,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for ShaderCreateInfoEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ShaderCreateInfoEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("flags", &self.flags)
.field("stage", &self.stage)
.field("next_stage", &self.next_stage)
.field("code_type", &self.code_type)
.field("code_size", &self.code_size)
.field("p_code", &self.p_code)
.field("p_name", &unsafe { as_c_str(self.p_name) })
.field("set_layout_count", &self.set_layout_count)
.field("p_set_layouts", &self.p_set_layouts)
.field("push_constant_range_count", &self.push_constant_range_count)
.field("p_push_constant_ranges", &self.p_push_constant_ranges)
.field("p_specialization_info", &self.p_specialization_info)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for ShaderCreateInfoEXT<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::SHADER_CREATE_INFO_EXT;
}
impl Default for ShaderCreateInfoEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
flags: Default::default(),
stage: Default::default(),
next_stage: Default::default(),
code_type: Default::default(),
code_size: Default::default(),
p_code: ptr::null(),
p_name: ptr::null(),
set_layout_count: Default::default(),
p_set_layouts: ptr::null(),
push_constant_range_count: Default::default(),
p_push_constant_ranges: ptr::null(),
p_specialization_info: ptr::null(),
_marker: PhantomData,
}
}
}
impl<'a> ShaderCreateInfoEXT<'a> {
#[inline]
pub fn flags(mut self, flags: ShaderCreateFlagsEXT) -> Self {
self.flags = flags;
self
}
#[inline]
pub fn stage(mut self, stage: ShaderStageFlagBits) -> Self {
self.stage = stage;
self
}
#[inline]
pub fn next_stage(mut self, next_stage: ShaderStageFlags) -> Self {
self.next_stage = next_stage;
self
}
#[inline]
pub fn code_type(mut self, code_type: ShaderCodeTypeEXT) -> Self {
self.code_type = code_type;
self
}
#[inline]
pub fn code(mut self, code: &'a [u8]) -> Self {
self.code_size = code.len().try_into().unwrap();
self.p_code = code.as_ptr() as _;
self
}
#[inline]
pub fn name(mut self, name: &'a CStr) -> Self {
self.p_name = name.as_ptr();
self
}
#[inline]
pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
self.set_layout_count = set_layouts.len().try_into().unwrap();
self.p_set_layouts = set_layouts.as_ptr() as _;
self
}
#[inline]
pub fn push_constant_ranges(
mut self,
push_constant_ranges: &'a [PushConstantRange],
) -> Self {
self.push_constant_range_count = push_constant_ranges.len().try_into().unwrap();
self.p_push_constant_ranges = push_constant_ranges.as_ptr() as _;
self
}
#[inline]
pub fn specialization_info(
mut self,
specialization_info: &'a SpecializationInfo<'a>,
) -> Self {
self.p_specialization_info = specialization_info;
self
}
}
#[repr(transparent)]
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ShaderCodeTypeEXT(i32);
impl ShaderCodeTypeEXT {
#[inline]
pub const fn from_raw(x: i32) -> Self {
Self(x)
}
#[inline]
pub const fn as_raw(self) -> i32 {
self.0
}
pub const BINARY_EXT: Self = Self(0);
pub const SPIRV_EXT: Self = Self(1);
}
impl fmt::Debug for ShaderCodeTypeEXT {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = match *self {
Self::BINARY_EXT => Some("BINARY_EXT"),
Self::SPIRV_EXT => Some("SPIRV_EXT"),
_ => None,
};
if let Some(name) = name {
f.write_str(name)
} else {
self.0.fmt(f)
}
}
}
#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub struct ShaderCreateFlagsEXT(Flags);
vk_bitflags_wrapped!(ShaderCreateFlagsEXT, Flags, ShaderCreateFlagBitsEXT);
impl fmt::Debug for ShaderCreateFlagsEXT {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
const KNOWN: &[(Flags, &str)] = &[
(ShaderCreateFlagBitsEXT::LINK_STAGE_EXT.0, "LINK_STAGE_EXT"),
(
ShaderCreateFlagBitsEXT::INSTRUMENT_SHADER_ARM.0,
"INSTRUMENT_SHADER_ARM",
),
(
ShaderCreateFlagBitsEXT::DESCRIPTOR_HEAP_EXT.0,
"DESCRIPTOR_HEAP_EXT",
),
(
ShaderCreateFlagBitsEXT::INDIRECT_BINDABLE_EXT.0,
"INDIRECT_BINDABLE_EXT",
),
(
ShaderCreateFlagBitsEXT::_64_INDEXING_EXT.0,
"_64_INDEXING_EXT",
),
(
ShaderCreateFlagBitsEXT::ALLOW_VARYING_SUBGROUP_SIZE_EXT.0,
"ALLOW_VARYING_SUBGROUP_SIZE_EXT",
),
(
ShaderCreateFlagBitsEXT::REQUIRE_FULL_SUBGROUPS_EXT.0,
"REQUIRE_FULL_SUBGROUPS_EXT",
),
(
ShaderCreateFlagBitsEXT::NO_TASK_SHADER_EXT.0,
"NO_TASK_SHADER_EXT",
),
(
ShaderCreateFlagBitsEXT::DISPATCH_BASE_EXT.0,
"DISPATCH_BASE_EXT",
),
(
ShaderCreateFlagBitsEXT::FRAGMENT_SHADING_RATE_ATTACHMENT_EXT.0,
"FRAGMENT_SHADING_RATE_ATTACHMENT_EXT",
),
(
ShaderCreateFlagBitsEXT::FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0,
"FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT",
),
(
ShaderCreateFlagBitsEXT::INDEPENDENT_SETS_KHR.0,
"INDEPENDENT_SETS_KHR",
),
(
ShaderCreateFlagBitsEXT::OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_EXT.0,
"OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_EXT",
),
];
debug_flags(f, KNOWN, self.0)
}
}
#[repr(transparent)]
#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
pub struct ShaderCreateFlagBitsEXT(u32);
impl ShaderCreateFlagBitsEXT {
pub const LINK_STAGE_EXT: Self = Self(1 << 0);
pub const INSTRUMENT_SHADER_ARM: Self = Self(1 << 11);
pub const DESCRIPTOR_HEAP_EXT: Self = Self(1 << 10);
pub const INDIRECT_BINDABLE_EXT: Self = Self(1 << 7);
pub const _64_INDEXING_EXT: Self = Self(1 << 15);
pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self(1 << 1);
pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self(1 << 2);
pub const NO_TASK_SHADER_EXT: Self = Self(1 << 3);
pub const DISPATCH_BASE_EXT: Self = Self(1 << 4);
pub const FRAGMENT_SHADING_RATE_ATTACHMENT_EXT: Self = Self(1 << 5);
pub const FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = Self(1 << 6);
pub const INDEPENDENT_SETS_KHR: Self = Self(1 << 18);
pub const OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_EXT: Self = Self(1 << 12);
}
impl fmt::Debug for ShaderCreateFlagBitsEXT {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = match *self {
Self::LINK_STAGE_EXT => Some("LINK_STAGE_EXT"),
Self::INSTRUMENT_SHADER_ARM => Some("INSTRUMENT_SHADER_ARM"),
Self::DESCRIPTOR_HEAP_EXT => Some("DESCRIPTOR_HEAP_EXT"),
Self::INDIRECT_BINDABLE_EXT => Some("INDIRECT_BINDABLE_EXT"),
Self::_64_INDEXING_EXT => Some("_64_INDEXING_EXT"),
Self::ALLOW_VARYING_SUBGROUP_SIZE_EXT => Some("ALLOW_VARYING_SUBGROUP_SIZE_EXT"),
Self::REQUIRE_FULL_SUBGROUPS_EXT => Some("REQUIRE_FULL_SUBGROUPS_EXT"),
Self::NO_TASK_SHADER_EXT => Some("NO_TASK_SHADER_EXT"),
Self::DISPATCH_BASE_EXT => Some("DISPATCH_BASE_EXT"),
Self::FRAGMENT_SHADING_RATE_ATTACHMENT_EXT => {
Some("FRAGMENT_SHADING_RATE_ATTACHMENT_EXT")
}
Self::FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT => {
Some("FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT")
}
Self::INDEPENDENT_SETS_KHR => Some("INDEPENDENT_SETS_KHR"),
Self::OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_EXT => {
Some("OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_EXT")
}
_ => None,
};
if let Some(name) = name {
f.write_str(name)
} else {
self.0.fmt(f)
}
}
}
pub type PFN_vkCreateShadersEXT = unsafe extern "system" fn(
device: Device,
create_info_count: u32,
p_create_infos: *const ShaderCreateInfoEXT<'_>,
p_allocator: *const AllocationCallbacks<'_>,
p_shaders: *mut ShaderEXT,
) -> vk::Result;
pub type PFN_vkDestroyShaderEXT = unsafe extern "system" fn(
device: Device,
shader: ShaderEXT,
p_allocator: *const AllocationCallbacks<'_>,
);
pub type PFN_vkGetShaderBinaryDataEXT = unsafe extern "system" fn(
device: Device,
shader: ShaderEXT,
p_data_size: *mut usize,
p_data: *mut c_void,
) -> vk::Result;
pub type PFN_vkCmdBindShadersEXT = unsafe extern "system" fn(
command_buffer: CommandBuffer,
stage_count: u32,
p_stages: *const ShaderStageFlagBits,
p_shaders: *const ShaderEXT,
);
pub type PFN_vkCmdSetDepthClampRangeEXT = unsafe extern "system" fn(
command_buffer: CommandBuffer,
depth_clamp_mode: DepthClampModeEXT,
p_depth_clamp_range: *const DepthClampRangeEXT,
);
}
#[cfg(feature = "ffi")]
pub(super) mod ffi {
#![allow(non_camel_case_types)]
use super::defs::*;
pub type VkShaderEXT = ShaderEXT;
pub type VkPhysicalDeviceShaderObjectFeaturesEXT =
PhysicalDeviceShaderObjectFeaturesEXT<'static>;
pub type VkPhysicalDeviceShaderObjectPropertiesEXT =
PhysicalDeviceShaderObjectPropertiesEXT<'static>;
pub type VkShaderCreateInfoEXT = ShaderCreateInfoEXT<'static>;
pub type VkShaderCodeTypeEXT = ShaderCodeTypeEXT;
pub type VkShaderCreateFlagsEXT = ShaderCreateFlagsEXT;
pub type VkShaderCreateFlagBitsEXT = ShaderCreateFlagBitsEXT;
pub type VkShaderRequiredSubgroupSizeCreateInfoEXT =
ShaderRequiredSubgroupSizeCreateInfoEXT<'static>;
impl PhysicalDeviceShaderObjectFeaturesEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceShaderObjectFeaturesEXT {
unsafe { core::mem::transmute(self) }
}
}
impl PhysicalDeviceShaderObjectPropertiesEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceShaderObjectPropertiesEXT {
unsafe { core::mem::transmute(self) }
}
}
impl ShaderCreateInfoEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkShaderCreateInfoEXT {
unsafe { core::mem::transmute(self) }
}
}
}
pub struct DeviceFn {
create_shaders: PFN_vkCreateShadersEXT,
destroy_shader: PFN_vkDestroyShaderEXT,
get_shader_binary_data: PFN_vkGetShaderBinaryDataEXT,
cmd_bind_shaders: PFN_vkCmdBindShadersEXT,
cmd_set_cull_mode: PFN_vkCmdSetCullMode,
cmd_set_front_face: PFN_vkCmdSetFrontFace,
cmd_set_primitive_topology: PFN_vkCmdSetPrimitiveTopology,
cmd_set_viewport_with_count: PFN_vkCmdSetViewportWithCount,
cmd_set_scissor_with_count: PFN_vkCmdSetScissorWithCount,
cmd_bind_vertex_buffers2: PFN_vkCmdBindVertexBuffers2,
cmd_set_depth_test_enable: PFN_vkCmdSetDepthTestEnable,
cmd_set_depth_write_enable: PFN_vkCmdSetDepthWriteEnable,
cmd_set_depth_compare_op: PFN_vkCmdSetDepthCompareOp,
cmd_set_depth_bounds_test_enable: PFN_vkCmdSetDepthBoundsTestEnable,
cmd_set_stencil_test_enable: PFN_vkCmdSetStencilTestEnable,
cmd_set_stencil_op: PFN_vkCmdSetStencilOp,
cmd_set_vertex_input: PFN_vkCmdSetVertexInputEXT,
cmd_set_patch_control_points: PFN_vkCmdSetPatchControlPointsEXT,
cmd_set_rasterizer_discard_enable: PFN_vkCmdSetRasterizerDiscardEnable,
cmd_set_depth_bias_enable: PFN_vkCmdSetDepthBiasEnable,
cmd_set_logic_op: PFN_vkCmdSetLogicOpEXT,
cmd_set_primitive_restart_enable: PFN_vkCmdSetPrimitiveRestartEnable,
cmd_set_tessellation_domain_origin: PFN_vkCmdSetTessellationDomainOriginEXT,
cmd_set_depth_clamp_enable: PFN_vkCmdSetDepthClampEnableEXT,
cmd_set_polygon_mode: PFN_vkCmdSetPolygonModeEXT,
cmd_set_rasterization_samples: PFN_vkCmdSetRasterizationSamplesEXT,
cmd_set_sample_mask: PFN_vkCmdSetSampleMaskEXT,
cmd_set_alpha_to_coverage_enable: PFN_vkCmdSetAlphaToCoverageEnableEXT,
cmd_set_alpha_to_one_enable: PFN_vkCmdSetAlphaToOneEnableEXT,
cmd_set_logic_op_enable: PFN_vkCmdSetLogicOpEnableEXT,
cmd_set_color_blend_enable: PFN_vkCmdSetColorBlendEnableEXT,
cmd_set_color_blend_equation: PFN_vkCmdSetColorBlendEquationEXT,
cmd_set_color_write_mask: PFN_vkCmdSetColorWriteMaskEXT,
cmd_set_rasterization_stream: Option<PFN_vkCmdSetRasterizationStreamEXT>,
cmd_set_conservative_rasterization_mode: Option<PFN_vkCmdSetConservativeRasterizationModeEXT>,
cmd_set_extra_primitive_overestimation_size:
Option<PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT>,
cmd_set_depth_clip_enable: Option<PFN_vkCmdSetDepthClipEnableEXT>,
cmd_set_sample_locations_enable: Option<PFN_vkCmdSetSampleLocationsEnableEXT>,
cmd_set_color_blend_advanced: Option<PFN_vkCmdSetColorBlendAdvancedEXT>,
cmd_set_provoking_vertex_mode: Option<PFN_vkCmdSetProvokingVertexModeEXT>,
cmd_set_line_rasterization_mode: Option<PFN_vkCmdSetLineRasterizationModeEXT>,
cmd_set_line_stipple_enable: Option<PFN_vkCmdSetLineStippleEnableEXT>,
cmd_set_depth_clip_negative_one_to_one: Option<PFN_vkCmdSetDepthClipNegativeOneToOneEXT>,
cmd_set_viewport_w_scaling_enable: Option<PFN_vkCmdSetViewportWScalingEnableNV>,
cmd_set_viewport_swizzle: Option<PFN_vkCmdSetViewportSwizzleNV>,
cmd_set_coverage_to_color_enable: Option<PFN_vkCmdSetCoverageToColorEnableNV>,
cmd_set_coverage_to_color_location: Option<PFN_vkCmdSetCoverageToColorLocationNV>,
cmd_set_coverage_modulation_mode: Option<PFN_vkCmdSetCoverageModulationModeNV>,
cmd_set_coverage_modulation_table_enable: Option<PFN_vkCmdSetCoverageModulationTableEnableNV>,
cmd_set_coverage_modulation_table: Option<PFN_vkCmdSetCoverageModulationTableNV>,
cmd_set_shading_rate_image_enable: Option<PFN_vkCmdSetShadingRateImageEnableNV>,
cmd_set_representative_fragment_test_enable:
Option<PFN_vkCmdSetRepresentativeFragmentTestEnableNV>,
cmd_set_coverage_reduction_mode: Option<PFN_vkCmdSetCoverageReductionModeNV>,
cmd_set_depth_clamp_range: Option<PFN_vkCmdSetDepthClampRangeEXT>,
}
impl LoadDeviceFn for DeviceFn {
unsafe fn load_with(
load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
) -> core::result::Result<Self, MissingEntryPointError> {
unsafe {
Ok(Self {
create_shaders: transmute(
load(c"vkCreateShadersEXT").ok_or(MissingEntryPointError)?,
),
destroy_shader: transmute(
load(c"vkDestroyShaderEXT").ok_or(MissingEntryPointError)?,
),
get_shader_binary_data: transmute(
load(c"vkGetShaderBinaryDataEXT").ok_or(MissingEntryPointError)?,
),
cmd_bind_shaders: transmute(
load(c"vkCmdBindShadersEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_cull_mode: transmute(
load(c"vkCmdSetCullModeEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_front_face: transmute(
load(c"vkCmdSetFrontFaceEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_primitive_topology: transmute(
load(c"vkCmdSetPrimitiveTopologyEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_viewport_with_count: transmute(
load(c"vkCmdSetViewportWithCountEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_scissor_with_count: transmute(
load(c"vkCmdSetScissorWithCountEXT").ok_or(MissingEntryPointError)?,
),
cmd_bind_vertex_buffers2: transmute(
load(c"vkCmdBindVertexBuffers2EXT").ok_or(MissingEntryPointError)?,
),
cmd_set_depth_test_enable: transmute(
load(c"vkCmdSetDepthTestEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_depth_write_enable: transmute(
load(c"vkCmdSetDepthWriteEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_depth_compare_op: transmute(
load(c"vkCmdSetDepthCompareOpEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_depth_bounds_test_enable: transmute(
load(c"vkCmdSetDepthBoundsTestEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_stencil_test_enable: transmute(
load(c"vkCmdSetStencilTestEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_stencil_op: transmute(
load(c"vkCmdSetStencilOpEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_vertex_input: transmute(
load(c"vkCmdSetVertexInputEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_patch_control_points: transmute(
load(c"vkCmdSetPatchControlPointsEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_rasterizer_discard_enable: transmute(
load(c"vkCmdSetRasterizerDiscardEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_depth_bias_enable: transmute(
load(c"vkCmdSetDepthBiasEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_logic_op: transmute(
load(c"vkCmdSetLogicOpEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_primitive_restart_enable: transmute(
load(c"vkCmdSetPrimitiveRestartEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_tessellation_domain_origin: transmute(
load(c"vkCmdSetTessellationDomainOriginEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_depth_clamp_enable: transmute(
load(c"vkCmdSetDepthClampEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_polygon_mode: transmute(
load(c"vkCmdSetPolygonModeEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_rasterization_samples: transmute(
load(c"vkCmdSetRasterizationSamplesEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_sample_mask: transmute(
load(c"vkCmdSetSampleMaskEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_alpha_to_coverage_enable: transmute(
load(c"vkCmdSetAlphaToCoverageEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_alpha_to_one_enable: transmute(
load(c"vkCmdSetAlphaToOneEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_logic_op_enable: transmute(
load(c"vkCmdSetLogicOpEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_color_blend_enable: transmute(
load(c"vkCmdSetColorBlendEnableEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_color_blend_equation: transmute(
load(c"vkCmdSetColorBlendEquationEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_color_write_mask: transmute(
load(c"vkCmdSetColorWriteMaskEXT").ok_or(MissingEntryPointError)?,
),
cmd_set_rasterization_stream: transmute(load(c"vkCmdSetRasterizationStreamEXT")),
cmd_set_conservative_rasterization_mode: transmute(load(
c"vkCmdSetConservativeRasterizationModeEXT",
)),
cmd_set_extra_primitive_overestimation_size: transmute(load(
c"vkCmdSetExtraPrimitiveOverestimationSizeEXT",
)),
cmd_set_depth_clip_enable: transmute(load(c"vkCmdSetDepthClipEnableEXT")),
cmd_set_sample_locations_enable: transmute(load(
c"vkCmdSetSampleLocationsEnableEXT",
)),
cmd_set_color_blend_advanced: transmute(load(c"vkCmdSetColorBlendAdvancedEXT")),
cmd_set_provoking_vertex_mode: transmute(load(c"vkCmdSetProvokingVertexModeEXT")),
cmd_set_line_rasterization_mode: transmute(load(
c"vkCmdSetLineRasterizationModeEXT",
)),
cmd_set_line_stipple_enable: transmute(load(c"vkCmdSetLineStippleEnableEXT")),
cmd_set_depth_clip_negative_one_to_one: transmute(load(
c"vkCmdSetDepthClipNegativeOneToOneEXT",
)),
cmd_set_viewport_w_scaling_enable: transmute(load(
c"vkCmdSetViewportWScalingEnableNV",
)),
cmd_set_viewport_swizzle: transmute(load(c"vkCmdSetViewportSwizzleNV")),
cmd_set_coverage_to_color_enable: transmute(load(
c"vkCmdSetCoverageToColorEnableNV",
)),
cmd_set_coverage_to_color_location: transmute(load(
c"vkCmdSetCoverageToColorLocationNV",
)),
cmd_set_coverage_modulation_mode: transmute(load(
c"vkCmdSetCoverageModulationModeNV",
)),
cmd_set_coverage_modulation_table_enable: transmute(load(
c"vkCmdSetCoverageModulationTableEnableNV",
)),
cmd_set_coverage_modulation_table: transmute(load(
c"vkCmdSetCoverageModulationTableNV",
)),
cmd_set_shading_rate_image_enable: transmute(load(
c"vkCmdSetShadingRateImageEnableNV",
)),
cmd_set_representative_fragment_test_enable: transmute(load(
c"vkCmdSetRepresentativeFragmentTestEnableNV",
)),
cmd_set_coverage_reduction_mode: transmute(load(
c"vkCmdSetCoverageReductionModeNV",
)),
cmd_set_depth_clamp_range: transmute(load(c"vkCmdSetDepthClampRangeEXT")),
})
}
}
}
impl DeviceFn {
#[inline]
pub unsafe fn create_shaders(
&self,
device: Device,
create_infos: &[ShaderCreateInfoEXT<'_>],
allocator: Option<&AllocationCallbacks<'_>>,
shaders: &mut [ShaderEXT],
) -> crate::Result<()> {
unsafe {
assert_eq!(shaders.len(), create_infos.len());
let result = (self.create_shaders)(
device,
create_infos.len().try_into().unwrap(),
create_infos.as_ptr() as _,
allocator.to_raw_ptr(),
shaders.as_mut_ptr() as _,
);
match result {
VkResult::SUCCESS => Ok(()),
err => Err(err),
}
}
}
#[inline]
pub unsafe fn destroy_shader(
&self,
device: Device,
shader: ShaderEXT,
allocator: Option<&AllocationCallbacks<'_>>,
) {
unsafe { (self.destroy_shader)(device, shader, allocator.to_raw_ptr()) }
}
#[inline]
pub unsafe fn get_shader_binary_data(
&self,
device: Device,
shader: ShaderEXT,
mut data: impl EnumerateInto<u8>,
) -> crate::Result<()> {
unsafe {
let call = |data_size, data| {
let result = (self.get_shader_binary_data)(device, shader, data_size, data as _);
match result {
VkResult::SUCCESS => Ok(()),
VkResult::INCOMPLETE => Ok(()),
err => Err(err),
}
};
let mut len = 0;
call(&mut len, std::ptr::null_mut())?;
let capacity = len.try_into().expect("failed to convert `N` to usize");
let data_buf = data.reserve(capacity);
len = data_buf.len().try_into().unwrap();
let result = call(&mut len, data_buf.as_mut_ptr() as *mut _)?;
data.set_len(len.try_into().unwrap());
Ok(result)
}
}
#[inline]
pub unsafe fn cmd_bind_shaders(
&self,
command_buffer: CommandBuffer,
stages: &[ShaderStageFlagBits],
shaders: Option<&[ShaderEXT]>,
) {
unsafe {
assert!(shaders.is_none_or(|s| s.len() == stages.len()));
(self.cmd_bind_shaders)(
command_buffer,
stages.len().try_into().unwrap(),
stages.as_ptr() as _,
shaders.to_raw_ptr(),
)
}
}
#[inline]
pub unsafe fn cmd_set_cull_mode(
&self,
command_buffer: CommandBuffer,
cull_mode: CullModeFlags,
) {
unsafe { (self.cmd_set_cull_mode)(command_buffer, cull_mode) }
}
#[inline]
pub unsafe fn cmd_set_front_face(&self, command_buffer: CommandBuffer, front_face: FrontFace) {
unsafe { (self.cmd_set_front_face)(command_buffer, front_face) }
}
#[inline]
pub unsafe fn cmd_set_primitive_topology(
&self,
command_buffer: CommandBuffer,
primitive_topology: PrimitiveTopology,
) {
unsafe { (self.cmd_set_primitive_topology)(command_buffer, primitive_topology) }
}
#[inline]
pub unsafe fn cmd_set_viewport_with_count(
&self,
command_buffer: CommandBuffer,
viewports: &[Viewport],
) {
unsafe {
(self.cmd_set_viewport_with_count)(
command_buffer,
viewports.len().try_into().unwrap(),
viewports.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_set_scissor_with_count(
&self,
command_buffer: CommandBuffer,
scissors: &[Rect2D],
) {
unsafe {
(self.cmd_set_scissor_with_count)(
command_buffer,
scissors.len().try_into().unwrap(),
scissors.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_bind_vertex_buffers2(
&self,
command_buffer: CommandBuffer,
first_binding: u32,
buffers: &[Buffer],
offsets: &[DeviceSize],
sizes: Option<&[DeviceSize]>,
strides: Option<&[DeviceSize]>,
) {
unsafe {
assert_eq!(offsets.len(), buffers.len());
assert!(sizes.is_none_or(|s| s.len() == buffers.len()));
assert!(strides.is_none_or(|s| s.len() == buffers.len()));
(self.cmd_bind_vertex_buffers2)(
command_buffer,
first_binding,
buffers.len().try_into().unwrap(),
buffers.as_ptr() as _,
offsets.as_ptr() as _,
sizes.to_raw_ptr(),
strides.to_raw_ptr(),
)
}
}
#[inline]
pub unsafe fn cmd_set_depth_test_enable(
&self,
command_buffer: CommandBuffer,
depth_test_enable: bool,
) {
unsafe { (self.cmd_set_depth_test_enable)(command_buffer, depth_test_enable.into()) }
}
#[inline]
pub unsafe fn cmd_set_depth_write_enable(
&self,
command_buffer: CommandBuffer,
depth_write_enable: bool,
) {
unsafe { (self.cmd_set_depth_write_enable)(command_buffer, depth_write_enable.into()) }
}
#[inline]
pub unsafe fn cmd_set_depth_compare_op(
&self,
command_buffer: CommandBuffer,
depth_compare_op: CompareOp,
) {
unsafe { (self.cmd_set_depth_compare_op)(command_buffer, depth_compare_op) }
}
#[inline]
pub unsafe fn cmd_set_depth_bounds_test_enable(
&self,
command_buffer: CommandBuffer,
depth_bounds_test_enable: bool,
) {
unsafe {
(self.cmd_set_depth_bounds_test_enable)(command_buffer, depth_bounds_test_enable.into())
}
}
#[inline]
pub unsafe fn cmd_set_stencil_test_enable(
&self,
command_buffer: CommandBuffer,
stencil_test_enable: bool,
) {
unsafe { (self.cmd_set_stencil_test_enable)(command_buffer, stencil_test_enable.into()) }
}
#[inline]
pub unsafe fn cmd_set_stencil_op(
&self,
command_buffer: CommandBuffer,
face_mask: StencilFaceFlags,
fail_op: StencilOp,
pass_op: StencilOp,
depth_fail_op: StencilOp,
compare_op: CompareOp,
) {
unsafe {
(self.cmd_set_stencil_op)(
command_buffer,
face_mask,
fail_op,
pass_op,
depth_fail_op,
compare_op,
)
}
}
#[inline]
pub unsafe fn cmd_set_vertex_input(
&self,
command_buffer: CommandBuffer,
vertex_binding_descriptions: &[VertexInputBindingDescription2EXT<'_>],
vertex_attribute_descriptions: &[VertexInputAttributeDescription2EXT<'_>],
) {
unsafe {
(self.cmd_set_vertex_input)(
command_buffer,
vertex_binding_descriptions.len().try_into().unwrap(),
vertex_binding_descriptions.as_ptr() as _,
vertex_attribute_descriptions.len().try_into().unwrap(),
vertex_attribute_descriptions.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_set_patch_control_points(
&self,
command_buffer: CommandBuffer,
patch_control_points: u32,
) {
unsafe { (self.cmd_set_patch_control_points)(command_buffer, patch_control_points) }
}
#[inline]
pub unsafe fn cmd_set_rasterizer_discard_enable(
&self,
command_buffer: CommandBuffer,
rasterizer_discard_enable: bool,
) {
unsafe {
(self.cmd_set_rasterizer_discard_enable)(
command_buffer,
rasterizer_discard_enable.into(),
)
}
}
#[inline]
pub unsafe fn cmd_set_depth_bias_enable(
&self,
command_buffer: CommandBuffer,
depth_bias_enable: bool,
) {
unsafe { (self.cmd_set_depth_bias_enable)(command_buffer, depth_bias_enable.into()) }
}
#[inline]
pub unsafe fn cmd_set_logic_op(&self, command_buffer: CommandBuffer, logic_op: LogicOp) {
unsafe { (self.cmd_set_logic_op)(command_buffer, logic_op) }
}
#[inline]
pub unsafe fn cmd_set_primitive_restart_enable(
&self,
command_buffer: CommandBuffer,
primitive_restart_enable: bool,
) {
unsafe {
(self.cmd_set_primitive_restart_enable)(command_buffer, primitive_restart_enable.into())
}
}
#[inline]
pub unsafe fn cmd_set_tessellation_domain_origin(
&self,
command_buffer: CommandBuffer,
domain_origin: TessellationDomainOrigin,
) {
unsafe { (self.cmd_set_tessellation_domain_origin)(command_buffer, domain_origin) }
}
#[inline]
pub unsafe fn cmd_set_depth_clamp_enable(
&self,
command_buffer: CommandBuffer,
depth_clamp_enable: bool,
) {
unsafe { (self.cmd_set_depth_clamp_enable)(command_buffer, depth_clamp_enable.into()) }
}
#[inline]
pub unsafe fn cmd_set_polygon_mode(
&self,
command_buffer: CommandBuffer,
polygon_mode: PolygonMode,
) {
unsafe { (self.cmd_set_polygon_mode)(command_buffer, polygon_mode) }
}
#[inline]
pub unsafe fn cmd_set_rasterization_samples(
&self,
command_buffer: CommandBuffer,
rasterization_samples: SampleCountFlagBits,
) {
unsafe { (self.cmd_set_rasterization_samples)(command_buffer, rasterization_samples) }
}
#[inline]
pub unsafe fn cmd_set_sample_mask(
&self,
command_buffer: CommandBuffer,
samples: SampleCountFlagBits,
sample_mask: Option<&[SampleMask]>,
) {
unsafe { (self.cmd_set_sample_mask)(command_buffer, samples, sample_mask.to_raw_ptr()) }
}
#[inline]
pub unsafe fn cmd_set_alpha_to_coverage_enable(
&self,
command_buffer: CommandBuffer,
alpha_to_coverage_enable: bool,
) {
unsafe {
(self.cmd_set_alpha_to_coverage_enable)(command_buffer, alpha_to_coverage_enable.into())
}
}
#[inline]
pub unsafe fn cmd_set_alpha_to_one_enable(
&self,
command_buffer: CommandBuffer,
alpha_to_one_enable: bool,
) {
unsafe { (self.cmd_set_alpha_to_one_enable)(command_buffer, alpha_to_one_enable.into()) }
}
#[inline]
pub unsafe fn cmd_set_logic_op_enable(
&self,
command_buffer: CommandBuffer,
logic_op_enable: bool,
) {
unsafe { (self.cmd_set_logic_op_enable)(command_buffer, logic_op_enable.into()) }
}
#[inline]
pub unsafe fn cmd_set_color_blend_enable(
&self,
command_buffer: CommandBuffer,
first_attachment: u32,
color_blend_enables: &[Bool32],
) {
unsafe {
(self.cmd_set_color_blend_enable)(
command_buffer,
first_attachment,
color_blend_enables.len().try_into().unwrap(),
color_blend_enables.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_set_color_blend_equation(
&self,
command_buffer: CommandBuffer,
first_attachment: u32,
color_blend_equations: &[ColorBlendEquationEXT],
) {
unsafe {
(self.cmd_set_color_blend_equation)(
command_buffer,
first_attachment,
color_blend_equations.len().try_into().unwrap(),
color_blend_equations.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_set_color_write_mask(
&self,
command_buffer: CommandBuffer,
first_attachment: u32,
color_write_masks: &[ColorComponentFlags],
) {
unsafe {
(self.cmd_set_color_write_mask)(
command_buffer,
first_attachment,
color_write_masks.len().try_into().unwrap(),
color_write_masks.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_set_rasterization_stream(
&self,
command_buffer: CommandBuffer,
rasterization_stream: u32,
) {
unsafe {
(self.cmd_set_rasterization_stream.unwrap())(command_buffer, rasterization_stream)
}
}
#[inline]
pub unsafe fn cmd_set_conservative_rasterization_mode(
&self,
command_buffer: CommandBuffer,
conservative_rasterization_mode: ConservativeRasterizationModeEXT,
) {
unsafe {
(self.cmd_set_conservative_rasterization_mode.unwrap())(
command_buffer,
conservative_rasterization_mode,
)
}
}
#[inline]
pub unsafe fn cmd_set_extra_primitive_overestimation_size(
&self,
command_buffer: CommandBuffer,
extra_primitive_overestimation_size: f32,
) {
unsafe {
(self.cmd_set_extra_primitive_overestimation_size.unwrap())(
command_buffer,
extra_primitive_overestimation_size,
)
}
}
#[inline]
pub unsafe fn cmd_set_depth_clip_enable(
&self,
command_buffer: CommandBuffer,
depth_clip_enable: bool,
) {
unsafe {
(self.cmd_set_depth_clip_enable.unwrap())(command_buffer, depth_clip_enable.into())
}
}
#[inline]
pub unsafe fn cmd_set_sample_locations_enable(
&self,
command_buffer: CommandBuffer,
sample_locations_enable: bool,
) {
unsafe {
(self.cmd_set_sample_locations_enable.unwrap())(
command_buffer,
sample_locations_enable.into(),
)
}
}
#[inline]
pub unsafe fn cmd_set_color_blend_advanced(
&self,
command_buffer: CommandBuffer,
first_attachment: u32,
color_blend_advanced: &[ColorBlendAdvancedEXT],
) {
unsafe {
(self.cmd_set_color_blend_advanced.unwrap())(
command_buffer,
first_attachment,
color_blend_advanced.len().try_into().unwrap(),
color_blend_advanced.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_set_provoking_vertex_mode(
&self,
command_buffer: CommandBuffer,
provoking_vertex_mode: ProvokingVertexModeEXT,
) {
unsafe {
(self.cmd_set_provoking_vertex_mode.unwrap())(command_buffer, provoking_vertex_mode)
}
}
#[inline]
pub unsafe fn cmd_set_line_rasterization_mode(
&self,
command_buffer: CommandBuffer,
line_rasterization_mode: LineRasterizationModeEXT,
) {
unsafe {
(self.cmd_set_line_rasterization_mode.unwrap())(command_buffer, line_rasterization_mode)
}
}
#[inline]
pub unsafe fn cmd_set_line_stipple_enable(
&self,
command_buffer: CommandBuffer,
stippled_line_enable: bool,
) {
unsafe {
(self.cmd_set_line_stipple_enable.unwrap())(command_buffer, stippled_line_enable.into())
}
}
#[inline]
pub unsafe fn cmd_set_depth_clip_negative_one_to_one(
&self,
command_buffer: CommandBuffer,
negative_one_to_one: bool,
) {
unsafe {
(self.cmd_set_depth_clip_negative_one_to_one.unwrap())(
command_buffer,
negative_one_to_one.into(),
)
}
}
#[inline]
pub unsafe fn cmd_set_viewport_w_scaling_enable(
&self,
command_buffer: CommandBuffer,
viewport_w_scaling_enable: bool,
) {
unsafe {
(self.cmd_set_viewport_w_scaling_enable.unwrap())(
command_buffer,
viewport_w_scaling_enable.into(),
)
}
}
#[inline]
pub unsafe fn cmd_set_viewport_swizzle(
&self,
command_buffer: CommandBuffer,
first_viewport: u32,
viewport_swizzles: &[ViewportSwizzleNV],
) {
unsafe {
(self.cmd_set_viewport_swizzle.unwrap())(
command_buffer,
first_viewport,
viewport_swizzles.len().try_into().unwrap(),
viewport_swizzles.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_set_coverage_to_color_enable(
&self,
command_buffer: CommandBuffer,
coverage_to_color_enable: bool,
) {
unsafe {
(self.cmd_set_coverage_to_color_enable.unwrap())(
command_buffer,
coverage_to_color_enable.into(),
)
}
}
#[inline]
pub unsafe fn cmd_set_coverage_to_color_location(
&self,
command_buffer: CommandBuffer,
coverage_to_color_location: u32,
) {
unsafe {
(self.cmd_set_coverage_to_color_location.unwrap())(
command_buffer,
coverage_to_color_location,
)
}
}
#[inline]
pub unsafe fn cmd_set_coverage_modulation_mode(
&self,
command_buffer: CommandBuffer,
coverage_modulation_mode: CoverageModulationModeNV,
) {
unsafe {
(self.cmd_set_coverage_modulation_mode.unwrap())(
command_buffer,
coverage_modulation_mode,
)
}
}
#[inline]
pub unsafe fn cmd_set_coverage_modulation_table_enable(
&self,
command_buffer: CommandBuffer,
coverage_modulation_table_enable: bool,
) {
unsafe {
(self.cmd_set_coverage_modulation_table_enable.unwrap())(
command_buffer,
coverage_modulation_table_enable.into(),
)
}
}
#[inline]
pub unsafe fn cmd_set_coverage_modulation_table(
&self,
command_buffer: CommandBuffer,
coverage_modulation_table: &[f32],
) {
unsafe {
(self.cmd_set_coverage_modulation_table.unwrap())(
command_buffer,
coverage_modulation_table.len().try_into().unwrap(),
coverage_modulation_table.as_ptr() as _,
)
}
}
#[inline]
pub unsafe fn cmd_set_shading_rate_image_enable(
&self,
command_buffer: CommandBuffer,
shading_rate_image_enable: bool,
) {
unsafe {
(self.cmd_set_shading_rate_image_enable.unwrap())(
command_buffer,
shading_rate_image_enable.into(),
)
}
}
#[inline]
pub unsafe fn cmd_set_representative_fragment_test_enable(
&self,
command_buffer: CommandBuffer,
representative_fragment_test_enable: bool,
) {
unsafe {
(self.cmd_set_representative_fragment_test_enable.unwrap())(
command_buffer,
representative_fragment_test_enable.into(),
)
}
}
#[inline]
pub unsafe fn cmd_set_coverage_reduction_mode(
&self,
command_buffer: CommandBuffer,
coverage_reduction_mode: CoverageReductionModeNV,
) {
unsafe {
(self.cmd_set_coverage_reduction_mode.unwrap())(command_buffer, coverage_reduction_mode)
}
}
#[inline]
pub unsafe fn cmd_set_depth_clamp_range(
&self,
command_buffer: CommandBuffer,
depth_clamp_mode: DepthClampModeEXT,
depth_clamp_range: Option<&DepthClampRangeEXT>,
) {
unsafe {
(self.cmd_set_depth_clamp_range.unwrap())(
command_buffer,
depth_clamp_mode,
depth_clamp_range.to_raw_ptr(),
)
}
}
}