extensions/ext: Add VK_EXT_mesh_shader

ash/src/extensions/ext/mesh_shader.rs

@@ -0,0 +1,87 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+#[derive(Clone)]
+pub struct MeshShader {
+    fp: vk::ExtMeshShaderFn,
+}
+
+impl MeshShader {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let fp = vk::ExtMeshShaderFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksEXT.html>
+    #[inline]
+    pub unsafe fn cmd_draw_mesh_tasks(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        group_count_x: u32,
+        group_count_y: u32,
+        group_count_z: u32,
+    ) {
+        (self.fp.cmd_draw_mesh_tasks_ext)(
+            command_buffer,
+            group_count_x,
+            group_count_y,
+            group_count_z,
+        );
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectEXT.html>
+    #[inline]
+    pub unsafe fn cmd_draw_mesh_tasks_indirect(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        buffer: vk::Buffer,
+        offset: vk::DeviceSize,
+        draw_count: u32,
+        stride: u32,
+    ) {
+        (self.fp.cmd_draw_mesh_tasks_indirect_ext)(
+            command_buffer,
+            buffer,
+            offset,
+            draw_count,
+            stride,
+        );
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html>
+    #[inline]
+    pub unsafe fn cmd_draw_mesh_tasks_indirect_count(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        buffer: vk::Buffer,
+        offset: vk::DeviceSize,
+        count_buffer: vk::Buffer,
+        count_buffer_offset: vk::DeviceSize,
+        max_draw_count: u32,
+        stride: u32,
+    ) {
+        (self.fp.cmd_draw_mesh_tasks_indirect_count_ext)(
+            command_buffer,
+            buffer,
+            offset,
+            count_buffer,
+            count_buffer_offset,
+            max_draw_count,
+            stride,
+        );
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtMeshShaderFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtMeshShaderFn {
+        &self.fp
+    }
+}

ash/src/extensions/ext/mod.rs

@@ -11,6 +11,7 @@ pub use self::full_screen_exclusive::FullScreenExclusive;
 pub use self::headless_surface::HeadlessSurface;
 pub use self::image_compression_control::ImageCompressionControl;
 pub use self::image_drm_format_modifier::ImageDrmFormatModifier;
+pub use self::mesh_shader::MeshShader;
 pub use self::metal_surface::MetalSurface;
 pub use self::physical_device_drm::PhysicalDeviceDrm;
 pub use self::private_data::PrivateData;
@@ -30,6 +31,7 @@ mod full_screen_exclusive;
 mod headless_surface;
 mod image_compression_control;
 mod image_drm_format_modifier;
+mod mesh_shader;
 mod metal_surface;
 mod physical_device_drm;
 mod private_data;

ash/src/vk/aliases.rs

@@ -261,3 +261,5 @@ pub type RenderingAttachmentInfoKHR<'a> = RenderingAttachmentInfo<'a>;
 pub type PhysicalDeviceDynamicRenderingFeaturesKHR<'a> = PhysicalDeviceDynamicRenderingFeatures<'a>;
 pub type CommandBufferInheritanceRenderingInfoKHR<'a> = CommandBufferInheritanceRenderingInfo<'a>;
 pub type AttachmentSampleCountInfoNV<'a> = AttachmentSampleCountInfoAMD<'a>;
+pub type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM<'a> =
+    PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a>;

ash/src/vk/bitflags.rs

@@ -1131,7 +1131,7 @@ impl GraphicsPipelineLibraryFlagsEXT {
 pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags);
 impl VideoCodecOperationFlagsKHR {
-    pub const INVALID: Self = Self(0);
+    pub const NONE: Self = Self(0);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -1171,21 +1171,10 @@ impl VideoCapabilityFlagsKHR {
 pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, Flags);
 impl VideoSessionCreateFlagsKHR {
-    pub const DEFAULT: Self = Self(0);
     pub const PROTECTED_CONTENT: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingQualityPresetFlagBitsKHR.html>"]
-pub struct VideoCodingQualityPresetFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoCodingQualityPresetFlagsKHR, Flags);
-impl VideoCodingQualityPresetFlagsKHR {
-    pub const NORMAL: Self = Self(0b1);
-    pub const POWER: Self = Self(0b10);
-    pub const QUALITY: Self = Self(0b100);
-}
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsEXT.html>"]
 pub struct VideoDecodeH264PictureLayoutFlagsEXT(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsEXT, Flags);
@@ -1200,57 +1189,61 @@ impl VideoDecodeH264PictureLayoutFlagsEXT {
 pub struct VideoCodingControlFlagsKHR(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, Flags);
 impl VideoCodingControlFlagsKHR {
-    pub const DEFAULT: Self = Self(0);
     pub const RESET: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeUsageFlagBitsKHR.html>"]
+pub struct VideoDecodeUsageFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoDecodeUsageFlagsKHR, Flags);
+impl VideoDecodeUsageFlagsKHR {
+    pub const DEFAULT: Self = Self(0);
+    pub const TRANSCODING: Self = Self(0b1);
+    pub const OFFLINE: Self = Self(0b10);
+    pub const STREAMING: Self = Self(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilityFlagBitsKHR.html>"]
 pub struct VideoDecodeCapabilityFlagsKHR(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoDecodeCapabilityFlagsKHR, Flags);
 impl VideoDecodeCapabilityFlagsKHR {
-    pub const DEFAULT: Self = Self(0);
     pub const DPB_AND_OUTPUT_COINCIDE: Self = Self(0b1);
     pub const DPB_AND_OUTPUT_DISTINCT: Self = Self(0b10);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeFlagBitsKHR.html>"]
-pub struct VideoDecodeFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoDecodeFlagsKHR, Flags);
-impl VideoDecodeFlagsKHR {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeUsageFlagBitsKHR.html>"]
+pub struct VideoEncodeUsageFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeUsageFlagsKHR, Flags);
+impl VideoEncodeUsageFlagsKHR {
     pub const DEFAULT: Self = Self(0);
-    pub const RESERVED_0: Self = Self(0b1);
+    pub const TRANSCODING: Self = Self(0b1);
+    pub const STREAMING: Self = Self(0b10);
+    pub const RECORDING: Self = Self(0b100);
+    pub const CONFERENCING: Self = Self(0b1000);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeFlagBitsKHR.html>"]
-pub struct VideoEncodeFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeFlagsKHR, Flags);
-impl VideoEncodeFlagsKHR {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeContentFlagBitsKHR.html>"]
+pub struct VideoEncodeContentFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeContentFlagsKHR, Flags);
+impl VideoEncodeContentFlagsKHR {
     pub const DEFAULT: Self = Self(0);
-    pub const RESERVED_0: Self = Self(0b1);
+    pub const CAMERA: Self = Self(0b1);
+    pub const DESKTOP: Self = Self(0b10);
+    pub const RENDERED: Self = Self(0b100);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeCapabilityFlagBitsKHR.html>"]
 pub struct VideoEncodeCapabilityFlagsKHR(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoEncodeCapabilityFlagsKHR, Flags);
 impl VideoEncodeCapabilityFlagsKHR {
-    pub const DEFAULT: Self = Self(0);
     pub const PRECEDING_EXTERNALLY_ENCODED_BYTES: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlFlagBitsKHR.html>"]
-pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags);
-impl VideoEncodeRateControlFlagsKHR {
-    pub const DEFAULT: Self = Self(0);
-    pub const RESERVED_0: Self = Self(0b1);
-}
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html>"]
 pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, Flags);
@@ -1313,16 +1306,6 @@ impl VideoEncodeH264OutputModeFlagsEXT {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlStructureFlagBitsEXT.html>"]
-pub struct VideoEncodeH264RateControlStructureFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeH264RateControlStructureFlagsEXT, Flags);
-impl VideoEncodeH264RateControlStructureFlagsEXT {
-    pub const UNKNOWN: Self = Self(0);
-    pub const FLAT: Self = Self(0b1);
-    pub const DYADIC: Self = Self(0b10);
-}
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html>"]
 pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags);
 vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags);
@@ -1478,16 +1461,6 @@ impl VideoEncodeH265OutputModeFlagsEXT {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlStructureFlagBitsEXT.html>"]
-pub struct VideoEncodeH265RateControlStructureFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeH265RateControlStructureFlagsEXT, Flags);
-impl VideoEncodeH265RateControlStructureFlagsEXT {
-    pub const UNKNOWN: Self = Self(0);
-    pub const FLAT: Self = Self(0b1);
-    pub const DYADIC: Self = Self(0b10);
-}
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CtbSizeFlagBitsEXT.html>"]
 pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, Flags);