Split vk.rs into multiple files (#286)
* Allow the generator to be run from project root dir * Split vk.rs into multiple files * Breakup and remove generated vk/prelude.rs Generator changes: - No longer convert current dir to a string when checking if the path ends with 'generator' - Pass the 'ash/src' dir instead of the 'vk.rs' path Generated and generated output changes: - The majority of prelude.rs has been moved to macros.rs - The pointer chain and Handle are now included in vk.rs - Platform types has been moved to its own file.
This commit is contained in:
aloucks
GitHub
parent
bb720dd726
commit
bd6515ced8
83178
ash/src/vk.rs
83178
ash/src/vk.rs
File diff suppressed because it is too large
Load diff
171
ash/src/vk/aliases.rs
Normal file
171
ash/src/vk/aliases.rs
Normal file
|
|
@ -0,0 +1,171 @@
|
|||
use crate::vk::bitflags::*;
|
||||
use crate::vk::definitions::*;
|
||||
use crate::vk::enums::*;
|
||||
pub type GeometryFlagsNV = GeometryFlagsKHR;
|
||||
pub type GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR;
|
||||
pub type BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR;
|
||||
pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
|
||||
pub type SemaphoreWaitFlagsKHR = SemaphoreWaitFlags;
|
||||
pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
|
||||
pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags;
|
||||
pub type CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
|
||||
pub type ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
|
||||
pub type ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
|
||||
pub type ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
|
||||
pub type ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
|
||||
pub type SemaphoreImportFlagsKHR = SemaphoreImportFlags;
|
||||
pub type ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
|
||||
pub type ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
|
||||
pub type FenceImportFlagsKHR = FenceImportFlags;
|
||||
pub type DescriptorBindingFlagsEXT = DescriptorBindingFlags;
|
||||
pub type ResolveModeFlagsKHR = ResolveModeFlags;
|
||||
pub type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
|
||||
pub type SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
|
||||
pub type AccelerationStructureNV = AccelerationStructureKHR;
|
||||
pub type DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType;
|
||||
pub type PointClippingBehaviorKHR = PointClippingBehavior;
|
||||
pub type SemaphoreTypeKHR = SemaphoreType;
|
||||
pub type CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR;
|
||||
pub type AccelerationStructureTypeNV = AccelerationStructureTypeKHR;
|
||||
pub type GeometryTypeNV = GeometryTypeKHR;
|
||||
pub type RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR;
|
||||
pub type AccelerationStructureMemoryRequirementsTypeNV =
|
||||
AccelerationStructureMemoryRequirementsTypeKHR;
|
||||
pub type TessellationDomainOriginKHR = TessellationDomainOrigin;
|
||||
pub type SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion;
|
||||
pub type SamplerYcbcrRangeKHR = SamplerYcbcrRange;
|
||||
pub type ChromaLocationKHR = ChromaLocation;
|
||||
pub type SamplerReductionModeEXT = SamplerReductionMode;
|
||||
pub type ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence;
|
||||
pub type DriverIdKHR = DriverId;
|
||||
pub type PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
|
||||
pub type PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
|
||||
pub type FormatProperties2KHR = FormatProperties2;
|
||||
pub type ImageFormatProperties2KHR = ImageFormatProperties2;
|
||||
pub type PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
|
||||
pub type QueueFamilyProperties2KHR = QueueFamilyProperties2;
|
||||
pub type PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
|
||||
pub type SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
|
||||
pub type PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
|
||||
pub type ConformanceVersionKHR = ConformanceVersion;
|
||||
pub type PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
|
||||
pub type PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
|
||||
pub type PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
|
||||
pub type PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
|
||||
pub type ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
|
||||
pub type PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
|
||||
pub type ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
|
||||
pub type PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
|
||||
pub type ExternalBufferPropertiesKHR = ExternalBufferProperties;
|
||||
pub type PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
|
||||
pub type ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
|
||||
pub type ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
|
||||
pub type ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
|
||||
pub type PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
|
||||
pub type ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
|
||||
pub type ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
|
||||
pub type PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
|
||||
pub type ExternalFencePropertiesKHR = ExternalFenceProperties;
|
||||
pub type ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
|
||||
pub type PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
|
||||
pub type PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
|
||||
pub type RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
|
||||
pub type PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
|
||||
pub type MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
|
||||
pub type BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
|
||||
pub type BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
|
||||
pub type BindImageMemoryInfoKHR = BindImageMemoryInfo;
|
||||
pub type BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
|
||||
pub type DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
|
||||
pub type DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
|
||||
pub type DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
|
||||
pub type DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
|
||||
pub type DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
|
||||
pub type DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
|
||||
pub type DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
|
||||
pub type InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
|
||||
pub type RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
|
||||
pub type PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
|
||||
pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR =
|
||||
PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
|
||||
pub type BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
|
||||
pub type ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
|
||||
pub type ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
|
||||
pub type MemoryRequirements2KHR = MemoryRequirements2;
|
||||
pub type SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
|
||||
pub type PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
|
||||
pub type MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
|
||||
pub type MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
|
||||
pub type ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
|
||||
pub type PipelineTessellationDomainOriginStateCreateInfoKHR =
|
||||
PipelineTessellationDomainOriginStateCreateInfo;
|
||||
pub type SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
|
||||
pub type SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
|
||||
pub type BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
|
||||
pub type ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
|
||||
pub type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR =
|
||||
PhysicalDeviceSamplerYcbcrConversionFeatures;
|
||||
pub type SamplerYcbcrConversionImageFormatPropertiesKHR =
|
||||
SamplerYcbcrConversionImageFormatProperties;
|
||||
pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT =
|
||||
PhysicalDeviceSamplerFilterMinmaxProperties;
|
||||
pub type SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
|
||||
pub type ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
|
||||
pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
|
||||
pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
|
||||
pub type PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
|
||||
pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
|
||||
pub type PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
|
||||
pub type PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
|
||||
pub type PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
|
||||
pub type PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
|
||||
pub type PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
|
||||
pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
|
||||
pub type DescriptorSetVariableDescriptorCountAllocateInfoEXT =
|
||||
DescriptorSetVariableDescriptorCountAllocateInfo;
|
||||
pub type DescriptorSetVariableDescriptorCountLayoutSupportEXT =
|
||||
DescriptorSetVariableDescriptorCountLayoutSupport;
|
||||
pub type AttachmentDescription2KHR = AttachmentDescription2;
|
||||
pub type AttachmentReference2KHR = AttachmentReference2;
|
||||
pub type SubpassDescription2KHR = SubpassDescription2;
|
||||
pub type SubpassDependency2KHR = SubpassDependency2;
|
||||
pub type RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
|
||||
pub type SubpassBeginInfoKHR = SubpassBeginInfo;
|
||||
pub type SubpassEndInfoKHR = SubpassEndInfo;
|
||||
pub type PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
|
||||
pub type PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
|
||||
pub type SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
|
||||
pub type TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
|
||||
pub type SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
|
||||
pub type SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
|
||||
pub type PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
|
||||
pub type PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
|
||||
pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
|
||||
pub type PhysicalDeviceDepthStencilResolvePropertiesKHR =
|
||||
PhysicalDeviceDepthStencilResolveProperties;
|
||||
pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
|
||||
pub type BindAccelerationStructureMemoryInfoNV = BindAccelerationStructureMemoryInfoKHR;
|
||||
pub type WriteDescriptorSetAccelerationStructureNV = WriteDescriptorSetAccelerationStructureKHR;
|
||||
pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
|
||||
pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
|
||||
pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR =
|
||||
PhysicalDeviceUniformBufferStandardLayoutFeatures;
|
||||
pub type PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
|
||||
pub type PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
|
||||
pub type BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
|
||||
pub type BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
|
||||
pub type BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
|
||||
pub type PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
|
||||
pub type FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
|
||||
pub type FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
|
||||
pub type RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
|
||||
pub type QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
|
||||
pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR =
|
||||
PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
|
||||
pub type AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
|
||||
pub type AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
|
||||
pub type MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
|
||||
pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
|
||||
pub type AabbPositionsNV = AabbPositionsKHR;
|
||||
pub type TransformMatrixNV = TransformMatrixKHR;
|
||||
pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
|
||||
969
ash/src/vk/bitflags.rs
Normal file
969
ash/src/vk/bitflags.rs
Normal file
|
|
@ -0,0 +1,969 @@
|
|||
use crate::vk::definitions::*;
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateFlagBits.html>"]
|
||||
pub struct PipelineCacheCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags);
|
||||
impl PipelineCacheCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCullModeFlagBits.html>"]
|
||||
pub struct CullModeFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags);
|
||||
impl CullModeFlags {
|
||||
pub const NONE: Self = CullModeFlags(0);
|
||||
pub const FRONT: Self = CullModeFlags(0b1);
|
||||
pub const BACK: Self = CullModeFlags(0b10);
|
||||
pub const FRONT_AND_BACK: Self = CullModeFlags(0x0000_0003);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFlagBits.html>"]
|
||||
pub struct QueueFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags);
|
||||
impl QueueFlags {
|
||||
#[doc = "Queue supports graphics operations"]
|
||||
pub const GRAPHICS: Self = QueueFlags(0b1);
|
||||
#[doc = "Queue supports compute operations"]
|
||||
pub const COMPUTE: Self = QueueFlags(0b10);
|
||||
#[doc = "Queue supports transfer operations"]
|
||||
pub const TRANSFER: Self = QueueFlags(0b100);
|
||||
#[doc = "Queue supports sparse resource memory management operations"]
|
||||
pub const SPARSE_BINDING: Self = QueueFlags(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateFlagBits.html>"]
|
||||
pub struct RenderPassCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags);
|
||||
impl RenderPassCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateFlagBits.html>"]
|
||||
pub struct DeviceQueueCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags);
|
||||
impl DeviceQueueCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPropertyFlagBits.html>"]
|
||||
pub struct MemoryPropertyFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(MemoryPropertyFlags, 0b1_1111, Flags);
|
||||
impl MemoryPropertyFlags {
|
||||
#[doc = "If otherwise stated, then allocate memory on device"]
|
||||
pub const DEVICE_LOCAL: Self = MemoryPropertyFlags(0b1);
|
||||
#[doc = "Memory is mappable by host"]
|
||||
pub const HOST_VISIBLE: Self = MemoryPropertyFlags(0b10);
|
||||
#[doc = "Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"]
|
||||
pub const HOST_COHERENT: Self = MemoryPropertyFlags(0b100);
|
||||
#[doc = "Memory will be cached by the host"]
|
||||
pub const HOST_CACHED: Self = MemoryPropertyFlags(0b1000);
|
||||
#[doc = "Memory may be allocated by the driver when it is required"]
|
||||
pub const LAZILY_ALLOCATED: Self = MemoryPropertyFlags(0b1_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeapFlagBits.html>"]
|
||||
pub struct MemoryHeapFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags);
|
||||
impl MemoryHeapFlags {
|
||||
#[doc = "If set, heap represents device memory"]
|
||||
pub const DEVICE_LOCAL: Self = MemoryHeapFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits.html>"]
|
||||
pub struct AccessFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(AccessFlags, 0b1_1111_1111_1111_1111, Flags);
|
||||
impl AccessFlags {
|
||||
#[doc = "Controls coherency of indirect command reads"]
|
||||
pub const INDIRECT_COMMAND_READ: Self = AccessFlags(0b1);
|
||||
#[doc = "Controls coherency of index reads"]
|
||||
pub const INDEX_READ: Self = AccessFlags(0b10);
|
||||
#[doc = "Controls coherency of vertex attribute reads"]
|
||||
pub const VERTEX_ATTRIBUTE_READ: Self = AccessFlags(0b100);
|
||||
#[doc = "Controls coherency of uniform buffer reads"]
|
||||
pub const UNIFORM_READ: Self = AccessFlags(0b1000);
|
||||
#[doc = "Controls coherency of input attachment reads"]
|
||||
pub const INPUT_ATTACHMENT_READ: Self = AccessFlags(0b1_0000);
|
||||
#[doc = "Controls coherency of shader reads"]
|
||||
pub const SHADER_READ: Self = AccessFlags(0b10_0000);
|
||||
#[doc = "Controls coherency of shader writes"]
|
||||
pub const SHADER_WRITE: Self = AccessFlags(0b100_0000);
|
||||
#[doc = "Controls coherency of color attachment reads"]
|
||||
pub const COLOR_ATTACHMENT_READ: Self = AccessFlags(0b1000_0000);
|
||||
#[doc = "Controls coherency of color attachment writes"]
|
||||
pub const COLOR_ATTACHMENT_WRITE: Self = AccessFlags(0b1_0000_0000);
|
||||
#[doc = "Controls coherency of depth/stencil attachment reads"]
|
||||
pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = AccessFlags(0b10_0000_0000);
|
||||
#[doc = "Controls coherency of depth/stencil attachment writes"]
|
||||
pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = AccessFlags(0b100_0000_0000);
|
||||
#[doc = "Controls coherency of transfer reads"]
|
||||
pub const TRANSFER_READ: Self = AccessFlags(0b1000_0000_0000);
|
||||
#[doc = "Controls coherency of transfer writes"]
|
||||
pub const TRANSFER_WRITE: Self = AccessFlags(0b1_0000_0000_0000);
|
||||
#[doc = "Controls coherency of host reads"]
|
||||
pub const HOST_READ: Self = AccessFlags(0b10_0000_0000_0000);
|
||||
#[doc = "Controls coherency of host writes"]
|
||||
pub const HOST_WRITE: Self = AccessFlags(0b100_0000_0000_0000);
|
||||
#[doc = "Controls coherency of memory reads"]
|
||||
pub const MEMORY_READ: Self = AccessFlags(0b1000_0000_0000_0000);
|
||||
#[doc = "Controls coherency of memory writes"]
|
||||
pub const MEMORY_WRITE: Self = AccessFlags(0b1_0000_0000_0000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferUsageFlagBits.html>"]
|
||||
pub struct BufferUsageFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(BufferUsageFlags, 0b1_1111_1111, Flags);
|
||||
impl BufferUsageFlags {
|
||||
#[doc = "Can be used as a source of transfer operations"]
|
||||
pub const TRANSFER_SRC: Self = BufferUsageFlags(0b1);
|
||||
#[doc = "Can be used as a destination of transfer operations"]
|
||||
pub const TRANSFER_DST: Self = BufferUsageFlags(0b10);
|
||||
#[doc = "Can be used as TBO"]
|
||||
pub const UNIFORM_TEXEL_BUFFER: Self = BufferUsageFlags(0b100);
|
||||
#[doc = "Can be used as IBO"]
|
||||
pub const STORAGE_TEXEL_BUFFER: Self = BufferUsageFlags(0b1000);
|
||||
#[doc = "Can be used as UBO"]
|
||||
pub const UNIFORM_BUFFER: Self = BufferUsageFlags(0b1_0000);
|
||||
#[doc = "Can be used as SSBO"]
|
||||
pub const STORAGE_BUFFER: Self = BufferUsageFlags(0b10_0000);
|
||||
#[doc = "Can be used as source of fixed-function index fetch (index buffer)"]
|
||||
pub const INDEX_BUFFER: Self = BufferUsageFlags(0b100_0000);
|
||||
#[doc = "Can be used as source of fixed-function vertex fetch (VBO)"]
|
||||
pub const VERTEX_BUFFER: Self = BufferUsageFlags(0b1000_0000);
|
||||
#[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"]
|
||||
pub const INDIRECT_BUFFER: Self = BufferUsageFlags(0b1_0000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateFlagBits.html>"]
|
||||
pub struct BufferCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags);
|
||||
impl BufferCreateFlags {
|
||||
#[doc = "Buffer should support sparse backing"]
|
||||
pub const SPARSE_BINDING: Self = BufferCreateFlags(0b1);
|
||||
#[doc = "Buffer should support sparse backing with partial residency"]
|
||||
pub const SPARSE_RESIDENCY: Self = BufferCreateFlags(0b10);
|
||||
#[doc = "Buffer should support constent data access to physical memory ranges mapped into multiple locations of sparse buffers"]
|
||||
pub const SPARSE_ALIASED: Self = BufferCreateFlags(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStageFlagBits.html>"]
|
||||
pub struct ShaderStageFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(
|
||||
ShaderStageFlags,
|
||||
0b111_1111_1111_1111_1111_1111_1111_1111,
|
||||
Flags
|
||||
);
|
||||
impl ShaderStageFlags {
|
||||
pub const VERTEX: Self = ShaderStageFlags(0b1);
|
||||
pub const TESSELLATION_CONTROL: Self = ShaderStageFlags(0b10);
|
||||
pub const TESSELLATION_EVALUATION: Self = ShaderStageFlags(0b100);
|
||||
pub const GEOMETRY: Self = ShaderStageFlags(0b1000);
|
||||
pub const FRAGMENT: Self = ShaderStageFlags(0b1_0000);
|
||||
pub const COMPUTE: Self = ShaderStageFlags(0b10_0000);
|
||||
pub const ALL_GRAPHICS: Self = ShaderStageFlags(0x0000_001F);
|
||||
pub const ALL: Self = ShaderStageFlags(0x7FFF_FFFF);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageUsageFlagBits.html>"]
|
||||
pub struct ImageUsageFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ImageUsageFlags, 0b1111_1111, Flags);
|
||||
impl ImageUsageFlags {
|
||||
#[doc = "Can be used as a source of transfer operations"]
|
||||
pub const TRANSFER_SRC: Self = ImageUsageFlags(0b1);
|
||||
#[doc = "Can be used as a destination of transfer operations"]
|
||||
pub const TRANSFER_DST: Self = ImageUsageFlags(0b10);
|
||||
#[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"]
|
||||
pub const SAMPLED: Self = ImageUsageFlags(0b100);
|
||||
#[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"]
|
||||
pub const STORAGE: Self = ImageUsageFlags(0b1000);
|
||||
#[doc = "Can be used as framebuffer color attachment"]
|
||||
pub const COLOR_ATTACHMENT: Self = ImageUsageFlags(0b1_0000);
|
||||
#[doc = "Can be used as framebuffer depth/stencil attachment"]
|
||||
pub const DEPTH_STENCIL_ATTACHMENT: Self = ImageUsageFlags(0b10_0000);
|
||||
#[doc = "Image data not needed outside of rendering"]
|
||||
pub const TRANSIENT_ATTACHMENT: Self = ImageUsageFlags(0b100_0000);
|
||||
#[doc = "Can be used as framebuffer input attachment"]
|
||||
pub const INPUT_ATTACHMENT: Self = ImageUsageFlags(0b1000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateFlagBits.html>"]
|
||||
pub struct ImageCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ImageCreateFlags, 0b1_1111, Flags);
|
||||
impl ImageCreateFlags {
|
||||
#[doc = "Image should support sparse backing"]
|
||||
pub const SPARSE_BINDING: Self = ImageCreateFlags(0b1);
|
||||
#[doc = "Image should support sparse backing with partial residency"]
|
||||
pub const SPARSE_RESIDENCY: Self = ImageCreateFlags(0b10);
|
||||
#[doc = "Image should support constent data access to physical memory ranges mapped into multiple locations of sparse images"]
|
||||
pub const SPARSE_ALIASED: Self = ImageCreateFlags(0b100);
|
||||
#[doc = "Allows image views to have different format than the base image"]
|
||||
pub const MUTABLE_FORMAT: Self = ImageCreateFlags(0b1000);
|
||||
#[doc = "Allows creating image views with cube type from the created image"]
|
||||
pub const CUBE_COMPATIBLE: Self = ImageCreateFlags(0b1_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateFlagBits.html>"]
|
||||
pub struct ImageViewCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags);
|
||||
impl ImageViewCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateFlagBits.html>"]
|
||||
pub struct SamplerCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags);
|
||||
impl SamplerCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreateFlagBits.html>"]
|
||||
pub struct PipelineCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags);
|
||||
impl PipelineCreateFlags {
|
||||
pub const DISABLE_OPTIMIZATION: Self = PipelineCreateFlags(0b1);
|
||||
pub const ALLOW_DERIVATIVES: Self = PipelineCreateFlags(0b10);
|
||||
pub const DERIVATIVE: Self = PipelineCreateFlags(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateFlagBits.html>"]
|
||||
pub struct PipelineShaderStageCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags);
|
||||
impl PipelineShaderStageCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkColorComponentFlagBits.html>"]
|
||||
pub struct ColorComponentFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags);
|
||||
impl ColorComponentFlags {
|
||||
pub const R: Self = ColorComponentFlags(0b1);
|
||||
pub const G: Self = ColorComponentFlags(0b10);
|
||||
pub const B: Self = ColorComponentFlags(0b100);
|
||||
pub const A: Self = ColorComponentFlags(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateFlagBits.html>"]
|
||||
pub struct FenceCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags);
|
||||
impl FenceCreateFlags {
|
||||
pub const SIGNALED: Self = FenceCreateFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateFlagBits.html>"]
|
||||
pub struct SemaphoreCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags);
|
||||
impl SemaphoreCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits.html>"]
|
||||
pub struct FormatFeatureFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(FormatFeatureFlags, 0b1_1111_1111_1111, Flags);
|
||||
impl FormatFeatureFlags {
|
||||
#[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"]
|
||||
pub const SAMPLED_IMAGE: Self = FormatFeatureFlags(0b1);
|
||||
#[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"]
|
||||
pub const STORAGE_IMAGE: Self = FormatFeatureFlags(0b10);
|
||||
#[doc = "Format supports atomic operations in case it is used for storage images"]
|
||||
pub const STORAGE_IMAGE_ATOMIC: Self = FormatFeatureFlags(0b100);
|
||||
#[doc = "Format can be used for uniform texel buffers (TBOs)"]
|
||||
pub const UNIFORM_TEXEL_BUFFER: Self = FormatFeatureFlags(0b1000);
|
||||
#[doc = "Format can be used for storage texel buffers (IBOs)"]
|
||||
pub const STORAGE_TEXEL_BUFFER: Self = FormatFeatureFlags(0b1_0000);
|
||||
#[doc = "Format supports atomic operations in case it is used for storage texel buffers"]
|
||||
pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = FormatFeatureFlags(0b10_0000);
|
||||
#[doc = "Format can be used for vertex buffers (VBOs)"]
|
||||
pub const VERTEX_BUFFER: Self = FormatFeatureFlags(0b100_0000);
|
||||
#[doc = "Format can be used for color attachment images"]
|
||||
pub const COLOR_ATTACHMENT: Self = FormatFeatureFlags(0b1000_0000);
|
||||
#[doc = "Format supports blending in case it is used for color attachment images"]
|
||||
pub const COLOR_ATTACHMENT_BLEND: Self = FormatFeatureFlags(0b1_0000_0000);
|
||||
#[doc = "Format can be used for depth/stencil attachment images"]
|
||||
pub const DEPTH_STENCIL_ATTACHMENT: Self = FormatFeatureFlags(0b10_0000_0000);
|
||||
#[doc = "Format can be used as the source image of blits with vkCmdBlitImage"]
|
||||
pub const BLIT_SRC: Self = FormatFeatureFlags(0b100_0000_0000);
|
||||
#[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"]
|
||||
pub const BLIT_DST: Self = FormatFeatureFlags(0b1000_0000_0000);
|
||||
#[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"]
|
||||
pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = FormatFeatureFlags(0b1_0000_0000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryControlFlagBits.html>"]
|
||||
pub struct QueryControlFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags);
|
||||
impl QueryControlFlags {
|
||||
#[doc = "Require precise results to be collected by the query"]
|
||||
pub const PRECISE: Self = QueryControlFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryResultFlagBits.html>"]
|
||||
pub struct QueryResultFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags);
|
||||
impl QueryResultFlags {
|
||||
#[doc = "Results of the queries are written to the destination buffer as 64-bit values"]
|
||||
pub const TYPE_64: Self = QueryResultFlags(0b1);
|
||||
#[doc = "Results of the queries are waited on before proceeding with the result copy"]
|
||||
pub const WAIT: Self = QueryResultFlags(0b10);
|
||||
#[doc = "Besides the results of the query, the availability of the results is also written"]
|
||||
pub const WITH_AVAILABILITY: Self = QueryResultFlags(0b100);
|
||||
#[doc = "Copy the partial results of the query even if the final results are not available"]
|
||||
pub const PARTIAL: Self = QueryResultFlags(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferUsageFlagBits.html>"]
|
||||
pub struct CommandBufferUsageFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags);
|
||||
impl CommandBufferUsageFlags {
|
||||
pub const ONE_TIME_SUBMIT: Self = CommandBufferUsageFlags(0b1);
|
||||
pub const RENDER_PASS_CONTINUE: Self = CommandBufferUsageFlags(0b10);
|
||||
#[doc = "Command buffer may be submitted/executed more than once simultaneously"]
|
||||
pub const SIMULTANEOUS_USE: Self = CommandBufferUsageFlags(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"]
|
||||
pub struct QueryPipelineStatisticFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b111_1111_1111, Flags);
|
||||
impl QueryPipelineStatisticFlags {
|
||||
#[doc = "Optional"]
|
||||
pub const INPUT_ASSEMBLY_VERTICES: Self = QueryPipelineStatisticFlags(0b1);
|
||||
#[doc = "Optional"]
|
||||
pub const INPUT_ASSEMBLY_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b10);
|
||||
#[doc = "Optional"]
|
||||
pub const VERTEX_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100);
|
||||
#[doc = "Optional"]
|
||||
pub const GEOMETRY_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b1000);
|
||||
#[doc = "Optional"]
|
||||
pub const GEOMETRY_SHADER_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b1_0000);
|
||||
#[doc = "Optional"]
|
||||
pub const CLIPPING_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10_0000);
|
||||
#[doc = "Optional"]
|
||||
pub const CLIPPING_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b100_0000);
|
||||
#[doc = "Optional"]
|
||||
pub const FRAGMENT_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b1000_0000);
|
||||
#[doc = "Optional"]
|
||||
pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self =
|
||||
QueryPipelineStatisticFlags(0b1_0000_0000);
|
||||
#[doc = "Optional"]
|
||||
pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self =
|
||||
QueryPipelineStatisticFlags(0b10_0000_0000);
|
||||
#[doc = "Optional"]
|
||||
pub const COMPUTE_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100_0000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageAspectFlagBits.html>"]
|
||||
pub struct ImageAspectFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags);
|
||||
impl ImageAspectFlags {
|
||||
pub const COLOR: Self = ImageAspectFlags(0b1);
|
||||
pub const DEPTH: Self = ImageAspectFlags(0b10);
|
||||
pub const STENCIL: Self = ImageAspectFlags(0b100);
|
||||
pub const METADATA: Self = ImageAspectFlags(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatFlagBits.html>"]
|
||||
pub struct SparseImageFormatFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags);
|
||||
impl SparseImageFormatFlags {
|
||||
#[doc = "Image uses a single mip tail region for all array layers"]
|
||||
pub const SINGLE_MIPTAIL: Self = SparseImageFormatFlags(0b1);
|
||||
#[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."]
|
||||
pub const ALIGNED_MIP_SIZE: Self = SparseImageFormatFlags(0b10);
|
||||
#[doc = "Image uses a non-standard sparse image block dimensions"]
|
||||
pub const NONSTANDARD_BLOCK_SIZE: Self = SparseImageFormatFlags(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBindFlagBits.html>"]
|
||||
pub struct SparseMemoryBindFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags);
|
||||
impl SparseMemoryBindFlags {
|
||||
#[doc = "Operation binds resource metadata to memory"]
|
||||
pub const METADATA: Self = SparseMemoryBindFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits.html>"]
|
||||
pub struct PipelineStageFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(PipelineStageFlags, 0b1_1111_1111_1111_1111, Flags);
|
||||
impl PipelineStageFlags {
|
||||
#[doc = "Before subsequent commands are processed"]
|
||||
pub const TOP_OF_PIPE: Self = PipelineStageFlags(0b1);
|
||||
#[doc = "Draw/DispatchIndirect command fetch"]
|
||||
pub const DRAW_INDIRECT: Self = PipelineStageFlags(0b10);
|
||||
#[doc = "Vertex/index fetch"]
|
||||
pub const VERTEX_INPUT: Self = PipelineStageFlags(0b100);
|
||||
#[doc = "Vertex shading"]
|
||||
pub const VERTEX_SHADER: Self = PipelineStageFlags(0b1000);
|
||||
#[doc = "Tessellation control shading"]
|
||||
pub const TESSELLATION_CONTROL_SHADER: Self = PipelineStageFlags(0b1_0000);
|
||||
#[doc = "Tessellation evaluation shading"]
|
||||
pub const TESSELLATION_EVALUATION_SHADER: Self = PipelineStageFlags(0b10_0000);
|
||||
#[doc = "Geometry shading"]
|
||||
pub const GEOMETRY_SHADER: Self = PipelineStageFlags(0b100_0000);
|
||||
#[doc = "Fragment shading"]
|
||||
pub const FRAGMENT_SHADER: Self = PipelineStageFlags(0b1000_0000);
|
||||
#[doc = "Early fragment (depth and stencil) tests"]
|
||||
pub const EARLY_FRAGMENT_TESTS: Self = PipelineStageFlags(0b1_0000_0000);
|
||||
#[doc = "Late fragment (depth and stencil) tests"]
|
||||
pub const LATE_FRAGMENT_TESTS: Self = PipelineStageFlags(0b10_0000_0000);
|
||||
#[doc = "Color attachment writes"]
|
||||
pub const COLOR_ATTACHMENT_OUTPUT: Self = PipelineStageFlags(0b100_0000_0000);
|
||||
#[doc = "Compute shading"]
|
||||
pub const COMPUTE_SHADER: Self = PipelineStageFlags(0b1000_0000_0000);
|
||||
#[doc = "Transfer/copy operations"]
|
||||
pub const TRANSFER: Self = PipelineStageFlags(0b1_0000_0000_0000);
|
||||
#[doc = "After previous commands have completed"]
|
||||
pub const BOTTOM_OF_PIPE: Self = PipelineStageFlags(0b10_0000_0000_0000);
|
||||
#[doc = "Indicates host (CPU) is a source/sink of the dependency"]
|
||||
pub const HOST: Self = PipelineStageFlags(0b100_0000_0000_0000);
|
||||
#[doc = "All stages of the graphics pipeline"]
|
||||
pub const ALL_GRAPHICS: Self = PipelineStageFlags(0b1000_0000_0000_0000);
|
||||
#[doc = "All stages supported on the queue"]
|
||||
pub const ALL_COMMANDS: Self = PipelineStageFlags(0b1_0000_0000_0000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateFlagBits.html>"]
|
||||
pub struct CommandPoolCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags);
|
||||
impl CommandPoolCreateFlags {
|
||||
#[doc = "Command buffers have a short lifetime"]
|
||||
pub const TRANSIENT: Self = CommandPoolCreateFlags(0b1);
|
||||
#[doc = "Command buffers may release their memory individually"]
|
||||
pub const RESET_COMMAND_BUFFER: Self = CommandPoolCreateFlags(0b10);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolResetFlagBits.html>"]
|
||||
pub struct CommandPoolResetFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags);
|
||||
impl CommandPoolResetFlags {
|
||||
#[doc = "Release resources owned by the pool"]
|
||||
pub const RELEASE_RESOURCES: Self = CommandPoolResetFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferResetFlagBits.html>"]
|
||||
pub struct CommandBufferResetFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags);
|
||||
impl CommandBufferResetFlags {
|
||||
#[doc = "Release resources owned by the buffer"]
|
||||
pub const RELEASE_RESOURCES: Self = CommandBufferResetFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleCountFlagBits.html>"]
|
||||
pub struct SampleCountFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SampleCountFlags, 0b111_1111, Flags);
|
||||
impl SampleCountFlags {
|
||||
#[doc = "Sample count 1 supported"]
|
||||
pub const TYPE_1: Self = SampleCountFlags(0b1);
|
||||
#[doc = "Sample count 2 supported"]
|
||||
pub const TYPE_2: Self = SampleCountFlags(0b10);
|
||||
#[doc = "Sample count 4 supported"]
|
||||
pub const TYPE_4: Self = SampleCountFlags(0b100);
|
||||
#[doc = "Sample count 8 supported"]
|
||||
pub const TYPE_8: Self = SampleCountFlags(0b1000);
|
||||
#[doc = "Sample count 16 supported"]
|
||||
pub const TYPE_16: Self = SampleCountFlags(0b1_0000);
|
||||
#[doc = "Sample count 32 supported"]
|
||||
pub const TYPE_32: Self = SampleCountFlags(0b10_0000);
|
||||
#[doc = "Sample count 64 supported"]
|
||||
pub const TYPE_64: Self = SampleCountFlags(0b100_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"]
|
||||
pub struct AttachmentDescriptionFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags);
|
||||
impl AttachmentDescriptionFlags {
|
||||
#[doc = "The attachment may alias physical memory of another attachment in the same render pass"]
|
||||
pub const MAY_ALIAS: Self = AttachmentDescriptionFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilFaceFlagBits.html>"]
|
||||
pub struct StencilFaceFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags);
|
||||
impl StencilFaceFlags {
|
||||
#[doc = "Front face"]
|
||||
pub const FRONT: Self = StencilFaceFlags(0b1);
|
||||
#[doc = "Back face"]
|
||||
pub const BACK: Self = StencilFaceFlags(0b10);
|
||||
#[doc = "Front and back faces"]
|
||||
pub const FRONT_AND_BACK: Self = StencilFaceFlags(0x0000_0003);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"]
|
||||
pub struct DescriptorPoolCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags);
|
||||
impl DescriptorPoolCreateFlags {
|
||||
#[doc = "Descriptor sets may be freed individually"]
|
||||
pub const FREE_DESCRIPTOR_SET: Self = DescriptorPoolCreateFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDependencyFlagBits.html>"]
|
||||
pub struct DependencyFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags);
|
||||
impl DependencyFlags {
|
||||
#[doc = "Dependency is per pixel region "]
|
||||
pub const BY_REGION: Self = DependencyFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitFlagBits.html>"]
|
||||
pub struct SemaphoreWaitFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SemaphoreWaitFlags, 0b1, Flags);
|
||||
impl SemaphoreWaitFlags {
|
||||
pub const ANY: Self = SemaphoreWaitFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html>"]
|
||||
pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags);
|
||||
impl DisplayPlaneAlphaFlagsKHR {
|
||||
pub const OPAQUE: Self = DisplayPlaneAlphaFlagsKHR(0b1);
|
||||
pub const GLOBAL: Self = DisplayPlaneAlphaFlagsKHR(0b10);
|
||||
pub const PER_PIXEL: Self = DisplayPlaneAlphaFlagsKHR(0b100);
|
||||
pub const PER_PIXEL_PREMULTIPLIED: Self = DisplayPlaneAlphaFlagsKHR(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"]
|
||||
pub struct CompositeAlphaFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags);
|
||||
impl CompositeAlphaFlagsKHR {
|
||||
pub const OPAQUE: Self = CompositeAlphaFlagsKHR(0b1);
|
||||
pub const PRE_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b10);
|
||||
pub const POST_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b100);
|
||||
pub const INHERIT: Self = CompositeAlphaFlagsKHR(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"]
|
||||
pub struct SurfaceTransformFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b1_1111_1111, Flags);
|
||||
impl SurfaceTransformFlagsKHR {
|
||||
pub const IDENTITY: Self = SurfaceTransformFlagsKHR(0b1);
|
||||
pub const ROTATE_90: Self = SurfaceTransformFlagsKHR(0b10);
|
||||
pub const ROTATE_180: Self = SurfaceTransformFlagsKHR(0b100);
|
||||
pub const ROTATE_270: Self = SurfaceTransformFlagsKHR(0b1000);
|
||||
pub const HORIZONTAL_MIRROR: Self = SurfaceTransformFlagsKHR(0b1_0000);
|
||||
pub const HORIZONTAL_MIRROR_ROTATE_90: Self = SurfaceTransformFlagsKHR(0b10_0000);
|
||||
pub const HORIZONTAL_MIRROR_ROTATE_180: Self = SurfaceTransformFlagsKHR(0b100_0000);
|
||||
pub const HORIZONTAL_MIRROR_ROTATE_270: Self = SurfaceTransformFlagsKHR(0b1000_0000);
|
||||
pub const INHERIT: Self = SurfaceTransformFlagsKHR(0b1_0000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"]
|
||||
pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, 0b1, Flags);
|
||||
impl SwapchainImageUsageFlagsANDROID {
|
||||
pub const SHARED: Self = SwapchainImageUsageFlagsANDROID(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportFlagBitsEXT.html>"]
|
||||
pub struct DebugReportFlagsEXT(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b1_1111, Flags);
|
||||
impl DebugReportFlagsEXT {
|
||||
pub const INFORMATION: Self = DebugReportFlagsEXT(0b1);
|
||||
pub const WARNING: Self = DebugReportFlagsEXT(0b10);
|
||||
pub const PERFORMANCE_WARNING: Self = DebugReportFlagsEXT(0b100);
|
||||
pub const ERROR: Self = DebugReportFlagsEXT(0b1000);
|
||||
pub const DEBUG: Self = DebugReportFlagsEXT(0b1_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"]
|
||||
pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags);
|
||||
impl ExternalMemoryHandleTypeFlagsNV {
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV: Self =
|
||||
ExternalMemoryHandleTypeFlagsNV(0b1);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV: Self =
|
||||
ExternalMemoryHandleTypeFlagsNV(0b10);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV: Self =
|
||||
ExternalMemoryHandleTypeFlagsNV(0b100);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV: Self =
|
||||
ExternalMemoryHandleTypeFlagsNV(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"]
|
||||
pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags);
|
||||
impl ExternalMemoryFeatureFlagsNV {
|
||||
pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV: Self = ExternalMemoryFeatureFlagsNV(0b1);
|
||||
pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b10);
|
||||
pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubgroupFeatureFlagBits.html>"]
|
||||
pub struct SubgroupFeatureFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b1111_1111, Flags);
|
||||
impl SubgroupFeatureFlags {
|
||||
#[doc = "Basic subgroup operations"]
|
||||
pub const BASIC: Self = SubgroupFeatureFlags(0b1);
|
||||
#[doc = "Vote subgroup operations"]
|
||||
pub const VOTE: Self = SubgroupFeatureFlags(0b10);
|
||||
#[doc = "Arithmetic subgroup operations"]
|
||||
pub const ARITHMETIC: Self = SubgroupFeatureFlags(0b100);
|
||||
#[doc = "Ballot subgroup operations"]
|
||||
pub const BALLOT: Self = SubgroupFeatureFlags(0b1000);
|
||||
#[doc = "Shuffle subgroup operations"]
|
||||
pub const SHUFFLE: Self = SubgroupFeatureFlags(0b1_0000);
|
||||
#[doc = "Shuffle relative subgroup operations"]
|
||||
pub const SHUFFLE_RELATIVE: Self = SubgroupFeatureFlags(0b10_0000);
|
||||
#[doc = "Clustered subgroup operations"]
|
||||
pub const CLUSTERED: Self = SubgroupFeatureFlags(0b100_0000);
|
||||
#[doc = "Quad subgroup operations"]
|
||||
pub const QUAD: Self = SubgroupFeatureFlags(0b1000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"]
|
||||
pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, 0b111, Flags);
|
||||
impl IndirectCommandsLayoutUsageFlagsNV {
|
||||
pub const EXPLICIT_PREPROCESS: Self = IndirectCommandsLayoutUsageFlagsNV(0b1);
|
||||
pub const INDEXED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNV(0b10);
|
||||
pub const UNORDERED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNV(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagBitsNV.html>"]
|
||||
pub struct IndirectStateFlagsNV(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(IndirectStateFlagsNV, 0b1, Flags);
|
||||
impl IndirectStateFlagsNV {
|
||||
pub const FLAG_FRONTFACE: Self = IndirectStateFlagsNV(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"]
|
||||
pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags);
|
||||
impl DescriptorSetLayoutCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"]
|
||||
pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b111_1111, Flags);
|
||||
impl ExternalMemoryHandleTypeFlags {
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: Self = ExternalMemoryHandleTypeFlags(0b1);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32: Self = ExternalMemoryHandleTypeFlags(0b10);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self =
|
||||
ExternalMemoryHandleTypeFlags(0b100);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE: Self =
|
||||
ExternalMemoryHandleTypeFlags(0b1000);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT: Self =
|
||||
ExternalMemoryHandleTypeFlags(0b1_0000);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP: Self =
|
||||
ExternalMemoryHandleTypeFlags(0b10_0000);
|
||||
pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE: Self =
|
||||
ExternalMemoryHandleTypeFlags(0b100_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"]
|
||||
pub struct ExternalMemoryFeatureFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags);
|
||||
impl ExternalMemoryFeatureFlags {
|
||||
pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY: Self = ExternalMemoryFeatureFlags(0b1);
|
||||
pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE: Self = ExternalMemoryFeatureFlags(0b10);
|
||||
pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE: Self = ExternalMemoryFeatureFlags(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"]
|
||||
pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b1_1111, Flags);
|
||||
impl ExternalSemaphoreHandleTypeFlags {
|
||||
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: Self =
|
||||
ExternalSemaphoreHandleTypeFlags(0b1);
|
||||
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32: Self =
|
||||
ExternalSemaphoreHandleTypeFlags(0b10);
|
||||
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self =
|
||||
ExternalSemaphoreHandleTypeFlags(0b100);
|
||||
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE: Self =
|
||||
ExternalSemaphoreHandleTypeFlags(0b1000);
|
||||
pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: Self =
|
||||
ExternalSemaphoreHandleTypeFlags(0b1_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"]
|
||||
pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags);
|
||||
impl ExternalSemaphoreFeatureFlags {
|
||||
pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b1);
|
||||
pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b10);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreImportFlagBits.html>"]
|
||||
pub struct SemaphoreImportFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags);
|
||||
impl SemaphoreImportFlags {
|
||||
pub const TEMPORARY: Self = SemaphoreImportFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"]
|
||||
pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags);
|
||||
impl ExternalFenceHandleTypeFlags {
|
||||
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD: Self = ExternalFenceHandleTypeFlags(0b1);
|
||||
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32: Self = ExternalFenceHandleTypeFlags(0b10);
|
||||
pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self =
|
||||
ExternalFenceHandleTypeFlags(0b100);
|
||||
pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD: Self = ExternalFenceHandleTypeFlags(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"]
|
||||
pub struct ExternalFenceFeatureFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags);
|
||||
impl ExternalFenceFeatureFlags {
|
||||
pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE: Self = ExternalFenceFeatureFlags(0b1);
|
||||
pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE: Self = ExternalFenceFeatureFlags(0b10);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceImportFlagBits.html>"]
|
||||
pub struct FenceImportFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags);
|
||||
impl FenceImportFlags {
|
||||
pub const TEMPORARY: Self = FenceImportFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"]
|
||||
pub struct SurfaceCounterFlagsEXT(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags);
|
||||
impl SurfaceCounterFlagsEXT {
|
||||
pub const VBLANK: Self = SurfaceCounterFlagsEXT(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"]
|
||||
pub struct PeerMemoryFeatureFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags);
|
||||
impl PeerMemoryFeatureFlags {
|
||||
#[doc = "Can read with vkCmdCopy commands"]
|
||||
pub const COPY_SRC: Self = PeerMemoryFeatureFlags(0b1);
|
||||
#[doc = "Can write with vkCmdCopy commands"]
|
||||
pub const COPY_DST: Self = PeerMemoryFeatureFlags(0b10);
|
||||
#[doc = "Can read with any access type/command"]
|
||||
pub const GENERIC_SRC: Self = PeerMemoryFeatureFlags(0b100);
|
||||
#[doc = "Can write with and access type/command"]
|
||||
pub const GENERIC_DST: Self = PeerMemoryFeatureFlags(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagBits.html>"]
|
||||
pub struct MemoryAllocateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags);
|
||||
impl MemoryAllocateFlags {
|
||||
#[doc = "Force allocation on specific devices"]
|
||||
pub const DEVICE_MASK: Self = MemoryAllocateFlags(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html>"]
|
||||
pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags);
|
||||
impl DeviceGroupPresentModeFlagsKHR {
|
||||
#[doc = "Present from local memory"]
|
||||
pub const LOCAL: Self = DeviceGroupPresentModeFlagsKHR(0b1);
|
||||
#[doc = "Present from remote memory"]
|
||||
pub const REMOTE: Self = DeviceGroupPresentModeFlagsKHR(0b10);
|
||||
#[doc = "Present sum of local and/or remote memory"]
|
||||
pub const SUM: Self = DeviceGroupPresentModeFlagsKHR(0b100);
|
||||
#[doc = "Each physical device presents from local memory"]
|
||||
pub const LOCAL_MULTI_DEVICE: Self = DeviceGroupPresentModeFlagsKHR(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"]
|
||||
pub struct SwapchainCreateFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags);
|
||||
impl SwapchainCreateFlagsKHR {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionFlagBits.html>"]
|
||||
pub struct SubpassDescriptionFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags);
|
||||
impl SubpassDescriptionFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"]
|
||||
pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1_0001_0001_0001, Flags);
|
||||
impl DebugUtilsMessageSeverityFlagsEXT {
|
||||
pub const VERBOSE: Self = DebugUtilsMessageSeverityFlagsEXT(0b1);
|
||||
pub const INFO: Self = DebugUtilsMessageSeverityFlagsEXT(0b1_0000);
|
||||
pub const WARNING: Self = DebugUtilsMessageSeverityFlagsEXT(0b1_0000_0000);
|
||||
pub const ERROR: Self = DebugUtilsMessageSeverityFlagsEXT(0b1_0000_0000_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"]
|
||||
pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags);
|
||||
impl DebugUtilsMessageTypeFlagsEXT {
|
||||
pub const GENERAL: Self = DebugUtilsMessageTypeFlagsEXT(0b1);
|
||||
pub const VALIDATION: Self = DebugUtilsMessageTypeFlagsEXT(0b10);
|
||||
pub const PERFORMANCE: Self = DebugUtilsMessageTypeFlagsEXT(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBindingFlagBits.html>"]
|
||||
pub struct DescriptorBindingFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DescriptorBindingFlags, 0b1111, Flags);
|
||||
impl DescriptorBindingFlags {
|
||||
pub const UPDATE_AFTER_BIND: Self = DescriptorBindingFlags(0b1);
|
||||
pub const UPDATE_UNUSED_WHILE_PENDING: Self = DescriptorBindingFlags(0b10);
|
||||
pub const PARTIALLY_BOUND: Self = DescriptorBindingFlags(0b100);
|
||||
pub const VARIABLE_DESCRIPTOR_COUNT: Self = DescriptorBindingFlags(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"]
|
||||
pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, 0b1, Flags);
|
||||
impl ConditionalRenderingFlagsEXT {
|
||||
pub const INVERTED: Self = ConditionalRenderingFlagsEXT(0b1);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveModeFlagBits.html>"]
|
||||
pub struct ResolveModeFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ResolveModeFlags, 0b1111, Flags);
|
||||
impl ResolveModeFlags {
|
||||
pub const NONE: Self = ResolveModeFlags(0);
|
||||
pub const SAMPLE_ZERO: Self = ResolveModeFlags(0b1);
|
||||
pub const AVERAGE: Self = ResolveModeFlags(0b10);
|
||||
pub const MIN: Self = ResolveModeFlags(0b100);
|
||||
pub const MAX: Self = ResolveModeFlags(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"]
|
||||
pub struct GeometryInstanceFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, 0b1111, Flags);
|
||||
impl GeometryInstanceFlagsKHR {
|
||||
pub const TRIANGLE_FACING_CULL_DISABLE: Self = GeometryInstanceFlagsKHR(0b1);
|
||||
pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = GeometryInstanceFlagsKHR(0b10);
|
||||
pub const FORCE_OPAQUE: Self = GeometryInstanceFlagsKHR(0b100);
|
||||
pub const FORCE_NO_OPAQUE: Self = GeometryInstanceFlagsKHR(0b1000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryFlagBitsKHR.html>"]
|
||||
pub struct GeometryFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(GeometryFlagsKHR, 0b11, Flags);
|
||||
impl GeometryFlagsKHR {
|
||||
pub const OPAQUE: Self = GeometryFlagsKHR(0b1);
|
||||
pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = GeometryFlagsKHR(0b10);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"]
|
||||
pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, 0b1_1111, Flags);
|
||||
impl BuildAccelerationStructureFlagsKHR {
|
||||
pub const ALLOW_UPDATE: Self = BuildAccelerationStructureFlagsKHR(0b1);
|
||||
pub const ALLOW_COMPACTION: Self = BuildAccelerationStructureFlagsKHR(0b10);
|
||||
pub const PREFER_FAST_TRACE: Self = BuildAccelerationStructureFlagsKHR(0b100);
|
||||
pub const PREFER_FAST_BUILD: Self = BuildAccelerationStructureFlagsKHR(0b1000);
|
||||
pub const LOW_MEMORY: Self = BuildAccelerationStructureFlagsKHR(0b1_0000);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateFlagBits.html>"]
|
||||
pub struct FramebufferCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags);
|
||||
impl FramebufferCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"]
|
||||
pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, 0b111, Flags);
|
||||
impl DeviceDiagnosticsConfigFlagsNV {
|
||||
pub const ENABLE_SHADER_DEBUG_INFO: Self = DeviceDiagnosticsConfigFlagsNV(0b1);
|
||||
pub const ENABLE_RESOURCE_TRACKING: Self = DeviceDiagnosticsConfigFlagsNV(0b10);
|
||||
pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = DeviceDiagnosticsConfigFlagsNV(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackFlagBitsEXT.html>"]
|
||||
pub struct PipelineCreationFeedbackFlagsEXT(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(PipelineCreationFeedbackFlagsEXT, 0b111, Flags);
|
||||
impl PipelineCreationFeedbackFlagsEXT {
|
||||
pub const VALID: Self = PipelineCreationFeedbackFlagsEXT(0b1);
|
||||
pub const APPLICATION_PIPELINE_CACHE_HIT: Self = PipelineCreationFeedbackFlagsEXT(0b10);
|
||||
pub const BASE_PIPELINE_ACCELERATION: Self = PipelineCreationFeedbackFlagsEXT(0b100);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"]
|
||||
pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, 0b11, Flags);
|
||||
impl PerformanceCounterDescriptionFlagsKHR {
|
||||
pub const PERFORMANCE_IMPACTING: Self = PerformanceCounterDescriptionFlagsKHR(0b1);
|
||||
pub const CONCURRENTLY_IMPACTED: Self = PerformanceCounterDescriptionFlagsKHR(0b10);
|
||||
}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"]
|
||||
pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, 0b0, Flags);
|
||||
impl AcquireProfilingLockFlagsKHR {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"]
|
||||
pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, 0b0, Flags);
|
||||
impl ShaderCorePropertiesFlagsAMD {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateFlagBits.html>"]
|
||||
pub struct ShaderModuleCreateFlags(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags);
|
||||
impl ShaderModuleCreateFlags {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"]
|
||||
pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, 0b0, Flags);
|
||||
impl PipelineCompilerControlFlagsAMD {}
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkToolPurposeFlagBitsEXT.html>"]
|
||||
pub struct ToolPurposeFlagsEXT(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(ToolPurposeFlagsEXT, 0b1_1111, Flags);
|
||||
impl ToolPurposeFlagsEXT {
|
||||
pub const VALIDATION: Self = ToolPurposeFlagsEXT(0b1);
|
||||
pub const PROFILING: Self = ToolPurposeFlagsEXT(0b10);
|
||||
pub const TRACING: Self = ToolPurposeFlagsEXT(0b100);
|
||||
pub const ADDITIONAL_FEATURES: Self = ToolPurposeFlagsEXT(0b1000);
|
||||
pub const MODIFYING_FEATURES: Self = ToolPurposeFlagsEXT(0b1_0000);
|
||||
}
|
||||
4514
ash/src/vk/const_debugs.rs
Normal file
4514
ash/src/vk/const_debugs.rs
Normal file
File diff suppressed because it is too large
Load diff
24
ash/src/vk/constants.rs
Normal file
24
ash/src/vk/constants.rs
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
use crate::vk::definitions::*;
|
||||
pub const MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = (256);
|
||||
pub const UUID_SIZE: usize = (16);
|
||||
pub const LUID_SIZE: usize = (8);
|
||||
pub const MAX_EXTENSION_NAME_SIZE: usize = (256);
|
||||
pub const MAX_DESCRIPTION_SIZE: usize = (256);
|
||||
pub const MAX_MEMORY_TYPES: usize = (32);
|
||||
pub const MAX_MEMORY_HEAPS: usize = (16);
|
||||
pub const LOD_CLAMP_NONE: f32 = (1000.00);
|
||||
pub const REMAINING_MIP_LEVELS: u32 = (!0);
|
||||
pub const REMAINING_ARRAY_LAYERS: u32 = (!0);
|
||||
pub const WHOLE_SIZE: u64 = (!0);
|
||||
pub const ATTACHMENT_UNUSED: u32 = (!0);
|
||||
pub const TRUE: Bool32 = (1);
|
||||
pub const FALSE: Bool32 = (0);
|
||||
pub const QUEUE_FAMILY_IGNORED: u32 = (!0);
|
||||
pub const QUEUE_FAMILY_EXTERNAL: u32 = (!0 - 1);
|
||||
pub const QUEUE_FAMILY_FOREIGN_EXT: u32 = (!0 - 2);
|
||||
pub const SUBPASS_EXTERNAL: u32 = (!0);
|
||||
pub const MAX_DEVICE_GROUP_SIZE: usize = (32);
|
||||
pub const MAX_DRIVER_NAME_SIZE: usize = (256);
|
||||
pub const MAX_DRIVER_INFO_SIZE: usize = (256);
|
||||
pub const SHADER_UNUSED_KHR: u32 = (!0);
|
||||
pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR;
|
||||
44905
ash/src/vk/definitions.rs
Normal file
44905
ash/src/vk/definitions.rs
Normal file
File diff suppressed because it is too large
Load diff
2104
ash/src/vk/enums.rs
Normal file
2104
ash/src/vk/enums.rs
Normal file
File diff suppressed because it is too large
Load diff
21881
ash/src/vk/extensions.rs
Normal file
21881
ash/src/vk/extensions.rs
Normal file
File diff suppressed because it is too large
Load diff
815
ash/src/vk/feature_extensions.rs
Normal file
815
ash/src/vk/feature_extensions.rs
Normal file
|
|
@ -0,0 +1,815 @@
|
|||
use crate::vk::bitflags::*;
|
||||
use crate::vk::enums::*;
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = StructureType(1_000_094_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const BIND_BUFFER_MEMORY_INFO: Self = StructureType(1_000_157_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const BIND_IMAGE_MEMORY_INFO: Self = StructureType(1_000_157_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageCreateFlags {
|
||||
pub const ALIAS: Self = ImageCreateFlags(0b100_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = StructureType(1_000_083_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const MEMORY_DEDICATED_REQUIREMENTS: Self = StructureType(1_000_127_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = StructureType(1_000_127_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = StructureType(1_000_060_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = StructureType(1_000_060_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = StructureType(1_000_060_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const DEVICE_GROUP_SUBMIT_INFO: Self = StructureType(1_000_060_005);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = StructureType(1_000_060_006);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl PipelineCreateFlags {
|
||||
pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = PipelineCreateFlags(0b1000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl PipelineCreateFlags {
|
||||
pub const DISPATCH_BASE: Self = PipelineCreateFlags(0b1_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl DependencyFlags {
|
||||
pub const DEVICE_GROUP: Self = DependencyFlags(0b100);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1_000_060_013);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1_000_060_014);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageCreateFlags {
|
||||
pub const SPLIT_INSTANCE_BIND_REGIONS: Self = ImageCreateFlags(0b100_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = StructureType(1_000_070_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = StructureType(1_000_070_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl MemoryHeapFlags {
|
||||
pub const MULTI_INSTANCE: Self = MemoryHeapFlags(0b10);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1_000_146_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1_000_146_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1_000_146_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const MEMORY_REQUIREMENTS_2: Self = StructureType(1_000_146_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = StructureType(1_000_146_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_FEATURES_2: Self = StructureType(1_000_059_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = StructureType(1_000_059_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const FORMAT_PROPERTIES_2: Self = StructureType(1_000_059_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1_000_059_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = StructureType(1_000_059_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const QUEUE_FAMILY_PROPERTIES_2: Self = StructureType(1_000_059_005);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = StructureType(1_000_059_006);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1_000_059_007);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = StructureType(1_000_059_008);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Result {
|
||||
pub const ERROR_OUT_OF_POOL_MEMORY: Self = Result(-1_000_069_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const TRANSFER_SRC: Self = FormatFeatureFlags(0b100_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const TRANSFER_DST: Self = FormatFeatureFlags(0b1000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageCreateFlags {
|
||||
pub const TYPE_2D_ARRAY_COMPATIBLE: Self = ImageCreateFlags(0b10_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageCreateFlags {
|
||||
pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = ImageCreateFlags(0b1000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageCreateFlags {
|
||||
pub const EXTENDED_USAGE: Self = ImageCreateFlags(0b1_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = StructureType(1_000_117_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = StructureType(1_000_117_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = StructureType(1_000_117_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self =
|
||||
StructureType(1_000_117_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageLayout {
|
||||
pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(1_000_117_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageLayout {
|
||||
pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(1_000_117_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = StructureType(1_000_053_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = StructureType(1_000_053_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = StructureType(1_000_053_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl DependencyFlags {
|
||||
pub const VIEW_LOCAL: Self = DependencyFlags(0b10);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = StructureType(1_000_120_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self =
|
||||
StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PROTECTED_SUBMIT_INFO: Self = StructureType(1_000_145_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = StructureType(1_000_145_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = StructureType(1_000_145_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const DEVICE_QUEUE_INFO_2: Self = StructureType(1_000_145_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl QueueFlags {
|
||||
pub const PROTECTED: Self = QueueFlags(0b1_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl DeviceQueueCreateFlags {
|
||||
pub const PROTECTED: Self = DeviceQueueCreateFlags(0b1);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl MemoryPropertyFlags {
|
||||
pub const PROTECTED: Self = MemoryPropertyFlags(0b10_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl BufferCreateFlags {
|
||||
pub const PROTECTED: Self = BufferCreateFlags(0b1000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageCreateFlags {
|
||||
pub const PROTECTED: Self = ImageCreateFlags(0b1000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl CommandPoolCreateFlags {
|
||||
pub const PROTECTED: Self = CommandPoolCreateFlags(0b100);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = StructureType(1_000_156_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = StructureType(1_000_156_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = StructureType(1_000_156_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = StructureType(1_000_156_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self =
|
||||
StructureType(1_000_156_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = StructureType(1_000_156_005);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ObjectType {
|
||||
pub const SAMPLER_YCBCR_CONVERSION: Self = ObjectType(1_000_156_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G8B8G8R8_422_UNORM: Self = Format(1_000_156_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const B8G8R8G8_422_UNORM: Self = Format(1_000_156_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G8_B8_R8_3PLANE_420_UNORM: Self = Format(1_000_156_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G8_B8R8_2PLANE_420_UNORM: Self = Format(1_000_156_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G8_B8_R8_3PLANE_422_UNORM: Self = Format(1_000_156_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G8_B8R8_2PLANE_422_UNORM: Self = Format(1_000_156_005);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G8_B8_R8_3PLANE_444_UNORM: Self = Format(1_000_156_006);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const R10X6_UNORM_PACK16: Self = Format(1_000_156_007);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const R10X6G10X6_UNORM_2PACK16: Self = Format(1_000_156_008);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Format(1_000_156_009);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Format(1_000_156_010);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Format(1_000_156_011);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Format(1_000_156_012);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Format(1_000_156_013);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Format(1_000_156_014);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Format(1_000_156_015);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Format(1_000_156_016);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const R12X4_UNORM_PACK16: Self = Format(1_000_156_017);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const R12X4G12X4_UNORM_2PACK16: Self = Format(1_000_156_018);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Format(1_000_156_019);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Format(1_000_156_020);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Format(1_000_156_021);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Format(1_000_156_022);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Format(1_000_156_023);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Format(1_000_156_024);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Format(1_000_156_025);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Format(1_000_156_026);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G16B16G16R16_422_UNORM: Self = Format(1_000_156_027);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const B16G16R16G16_422_UNORM: Self = Format(1_000_156_028);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G16_B16_R16_3PLANE_420_UNORM: Self = Format(1_000_156_029);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G16_B16R16_2PLANE_420_UNORM: Self = Format(1_000_156_030);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G16_B16_R16_3PLANE_422_UNORM: Self = Format(1_000_156_031);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G16_B16R16_2PLANE_422_UNORM: Self = Format(1_000_156_032);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Format {
|
||||
pub const G16_B16_R16_3PLANE_444_UNORM: Self = Format(1_000_156_033);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageAspectFlags {
|
||||
pub const PLANE_0: Self = ImageAspectFlags(0b1_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageAspectFlags {
|
||||
pub const PLANE_1: Self = ImageAspectFlags(0b10_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageAspectFlags {
|
||||
pub const PLANE_2: Self = ImageAspectFlags(0b100_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ImageCreateFlags {
|
||||
pub const DISJOINT: Self = ImageCreateFlags(0b10_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const MIDPOINT_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b10_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self =
|
||||
FormatFeatureFlags(0b100_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self =
|
||||
FormatFeatureFlags(0b1000_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self =
|
||||
FormatFeatureFlags(0b1_0000_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self =
|
||||
FormatFeatureFlags(0b10_0000_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const DISJOINT: Self = FormatFeatureFlags(0b100_0000_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const COSITED_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b1000_0000_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = StructureType(1_000_085_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl ObjectType {
|
||||
pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = ObjectType(1_000_085_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = StructureType(1_000_071_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = StructureType(1_000_071_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = StructureType(1_000_071_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXTERNAL_BUFFER_PROPERTIES: Self = StructureType(1_000_071_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = StructureType(1_000_071_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = StructureType(1_000_072_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = StructureType(1_000_072_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = StructureType(1_000_072_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl Result {
|
||||
pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Result(-1_000_072_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = StructureType(1_000_112_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXTERNAL_FENCE_PROPERTIES: Self = StructureType(1_000_112_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXPORT_FENCE_CREATE_INFO: Self = StructureType(1_000_113_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = StructureType(1_000_077_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = StructureType(1_000_076_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = StructureType(1_000_076_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = StructureType(1_000_168_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = StructureType(1_000_168_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: Self = StructureType(1_000_063_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_1\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self =
|
||||
StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = StructureType(49);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = StructureType(50);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = StructureType(51);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = StructureType(52);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = StructureType(1_000_147_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const ATTACHMENT_DESCRIPTION_2: Self = StructureType(1_000_109_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const ATTACHMENT_REFERENCE_2: Self = StructureType(1_000_109_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SUBPASS_DESCRIPTION_2: Self = StructureType(1_000_109_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SUBPASS_DEPENDENCY_2: Self = StructureType(1_000_109_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const RENDER_PASS_CREATE_INFO_2: Self = StructureType(1_000_109_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SUBPASS_BEGIN_INFO: Self = StructureType(1_000_109_005);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SUBPASS_END_INFO: Self = StructureType(1_000_109_006);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: Self = StructureType(1_000_177_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES: Self = StructureType(1_000_196_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: Self = StructureType(1_000_180_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: Self = StructureType(1_000_082_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: Self = StructureType(1_000_197_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: Self = StructureType(1_000_161_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: Self = StructureType(1_000_161_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: Self = StructureType(1_000_161_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: Self =
|
||||
StructureType(1_000_161_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: Self =
|
||||
StructureType(1_000_161_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl DescriptorPoolCreateFlags {
|
||||
pub const UPDATE_AFTER_BIND: Self = DescriptorPoolCreateFlags(0b10);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl DescriptorSetLayoutCreateFlags {
|
||||
pub const UPDATE_AFTER_BIND_POOL: Self = DescriptorSetLayoutCreateFlags(0b10);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl Result {
|
||||
pub const ERROR_FRAGMENTATION: Self = Result(-1_000_161_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: Self = StructureType(1_000_199_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: Self = StructureType(1_000_199_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: Self = StructureType(1_000_221_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const IMAGE_STENCIL_USAGE_CREATE_INFO: Self = StructureType(1_000_246_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: Self = StructureType(1_000_130_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SAMPLER_REDUCTION_MODE_CREATE_INFO: Self = StructureType(1_000_130_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl FormatFeatureFlags {
|
||||
pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = FormatFeatureFlags(0b1_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: Self = StructureType(1_000_211_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: Self = StructureType(1_000_108_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: Self = StructureType(1_000_108_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: Self = StructureType(1_000_108_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO: Self = StructureType(1_000_108_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl FramebufferCreateFlags {
|
||||
pub const IMAGELESS: Self = FramebufferCreateFlags(0b1);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: Self =
|
||||
StructureType(1_000_253_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: Self =
|
||||
StructureType(1_000_175_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: Self =
|
||||
StructureType(1_000_241_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT: Self = StructureType(1_000_241_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: Self = StructureType(1_000_241_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl ImageLayout {
|
||||
pub const DEPTH_ATTACHMENT_OPTIMAL: Self = ImageLayout(1_000_241_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl ImageLayout {
|
||||
pub const DEPTH_READ_ONLY_OPTIMAL: Self = ImageLayout(1_000_241_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl ImageLayout {
|
||||
pub const STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(1_000_241_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl ImageLayout {
|
||||
pub const STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(1_000_241_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: Self = StructureType(1_000_261_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: Self = StructureType(1_000_207_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: Self = StructureType(1_000_207_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SEMAPHORE_TYPE_CREATE_INFO: Self = StructureType(1_000_207_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const TIMELINE_SEMAPHORE_SUBMIT_INFO: Self = StructureType(1_000_207_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SEMAPHORE_WAIT_INFO: Self = StructureType(1_000_207_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const SEMAPHORE_SIGNAL_INFO: Self = StructureType(1_000_207_005);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: Self = StructureType(1_000_257_000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const BUFFER_DEVICE_ADDRESS_INFO: Self = StructureType(1_000_244_001);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: Self = StructureType(1_000_257_002);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: Self = StructureType(1_000_257_003);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl StructureType {
|
||||
pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: Self = StructureType(1_000_257_004);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl BufferUsageFlags {
|
||||
pub const SHADER_DEVICE_ADDRESS: Self = BufferUsageFlags(0b10_0000_0000_0000_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl BufferCreateFlags {
|
||||
pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = BufferCreateFlags(0b1_0000);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl MemoryAllocateFlags {
|
||||
pub const DEVICE_ADDRESS: Self = MemoryAllocateFlags(0b10);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl MemoryAllocateFlags {
|
||||
pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = MemoryAllocateFlags(0b100);
|
||||
}
|
||||
#[doc = "Generated from \'VK_VERSION_1_2\'"]
|
||||
impl Result {
|
||||
pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Result(-1_000_257_000);
|
||||
}
|
||||
7567
ash/src/vk/features.rs
Normal file
7567
ash/src/vk/features.rs
Normal file
File diff suppressed because it is too large
Load diff
199
ash/src/vk/macros.rs
Normal file
199
ash/src/vk/macros.rs
Normal file
|
|
@ -0,0 +1,199 @@
|
|||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_MAKE_VERSION.html>"]
|
||||
pub const fn make_version(major: u32, minor: u32, patch: u32) -> u32 {
|
||||
(major << 22) | (minor << 12) | patch
|
||||
}
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_MAJOR.html>"]
|
||||
pub const fn version_major(version: u32) -> u32 {
|
||||
version >> 22
|
||||
}
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_MINOR.html>"]
|
||||
pub const fn version_minor(version: u32) -> u32 {
|
||||
(version >> 12) & 0x3ff
|
||||
}
|
||||
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_PATCH.html>"]
|
||||
pub const fn version_patch(version: u32) -> u32 {
|
||||
version & 0xfff
|
||||
}
|
||||
#[macro_export]
|
||||
macro_rules! vk_bitflags_wrapped {
|
||||
( $ name : ident , $ all : expr , $ flag_type : ty ) => {
|
||||
impl Default for $name {
|
||||
fn default() -> $name {
|
||||
$name(0)
|
||||
}
|
||||
}
|
||||
impl $name {
|
||||
#[inline]
|
||||
pub const fn empty() -> $name {
|
||||
$name(0)
|
||||
}
|
||||
#[inline]
|
||||
pub const fn all() -> $name {
|
||||
$name($all)
|
||||
}
|
||||
#[inline]
|
||||
pub const fn from_raw(x: $flag_type) -> Self {
|
||||
$name(x)
|
||||
}
|
||||
#[inline]
|
||||
pub const fn as_raw(self) -> $flag_type {
|
||||
self.0
|
||||
}
|
||||
#[inline]
|
||||
pub fn is_empty(self) -> bool {
|
||||
self == $name::empty()
|
||||
}
|
||||
#[inline]
|
||||
pub fn is_all(self) -> bool {
|
||||
self & $name::all() == $name::all()
|
||||
}
|
||||
#[inline]
|
||||
pub fn intersects(self, other: $name) -> bool {
|
||||
self & other != $name::empty()
|
||||
}
|
||||
#[doc = r" Returns whether `other` is a subset of `self`"]
|
||||
#[inline]
|
||||
pub fn contains(self, other: $name) -> bool {
|
||||
self & other == other
|
||||
}
|
||||
}
|
||||
impl ::std::ops::BitOr for $name {
|
||||
type Output = $name;
|
||||
#[inline]
|
||||
fn bitor(self, rhs: $name) -> $name {
|
||||
$name(self.0 | rhs.0)
|
||||
}
|
||||
}
|
||||
impl ::std::ops::BitOrAssign for $name {
|
||||
#[inline]
|
||||
fn bitor_assign(&mut self, rhs: $name) {
|
||||
*self = *self | rhs
|
||||
}
|
||||
}
|
||||
impl ::std::ops::BitAnd for $name {
|
||||
type Output = $name;
|
||||
#[inline]
|
||||
fn bitand(self, rhs: $name) -> $name {
|
||||
$name(self.0 & rhs.0)
|
||||
}
|
||||
}
|
||||
impl ::std::ops::BitAndAssign for $name {
|
||||
#[inline]
|
||||
fn bitand_assign(&mut self, rhs: $name) {
|
||||
*self = *self & rhs
|
||||
}
|
||||
}
|
||||
impl ::std::ops::BitXor for $name {
|
||||
type Output = $name;
|
||||
#[inline]
|
||||
fn bitxor(self, rhs: $name) -> $name {
|
||||
$name(self.0 ^ rhs.0)
|
||||
}
|
||||
}
|
||||
impl ::std::ops::BitXorAssign for $name {
|
||||
#[inline]
|
||||
fn bitxor_assign(&mut self, rhs: $name) {
|
||||
*self = *self ^ rhs
|
||||
}
|
||||
}
|
||||
impl ::std::ops::Sub for $name {
|
||||
type Output = $name;
|
||||
#[inline]
|
||||
fn sub(self, rhs: $name) -> $name {
|
||||
self & !rhs
|
||||
}
|
||||
}
|
||||
impl ::std::ops::SubAssign for $name {
|
||||
#[inline]
|
||||
fn sub_assign(&mut self, rhs: $name) {
|
||||
*self = *self - rhs
|
||||
}
|
||||
}
|
||||
impl ::std::ops::Not for $name {
|
||||
type Output = $name;
|
||||
#[inline]
|
||||
fn not(self) -> $name {
|
||||
self ^ $name::all()
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
#[macro_export]
|
||||
macro_rules! handle_nondispatchable {
|
||||
( $ name : ident , $ ty : ident ) => {
|
||||
handle_nondispatchable!($name, $ty, doc = "");
|
||||
};
|
||||
( $ name : ident , $ ty : ident , $ doc_link : meta ) => {
|
||||
#[repr(transparent)]
|
||||
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)]
|
||||
#[$doc_link]
|
||||
pub struct $name(u64);
|
||||
impl Handle for $name {
|
||||
const TYPE: ObjectType = ObjectType::$ty;
|
||||
fn as_raw(self) -> u64 {
|
||||
self.0 as u64
|
||||
}
|
||||
fn from_raw(x: u64) -> Self {
|
||||
$name(x as _)
|
||||
}
|
||||
}
|
||||
impl $name {
|
||||
pub const fn null() -> $name {
|
||||
$name(0)
|
||||
}
|
||||
}
|
||||
impl fmt::Pointer for $name {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "0x{:x}", self.0)
|
||||
}
|
||||
}
|
||||
impl fmt::Debug for $name {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "0x{:x}", self.0)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
#[macro_export]
|
||||
macro_rules! define_handle {
|
||||
( $ name : ident , $ ty : ident ) => {
|
||||
define_handle!($name, $ty, doc = "");
|
||||
};
|
||||
( $ name : ident , $ ty : ident , $ doc_link : meta ) => {
|
||||
#[repr(transparent)]
|
||||
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)]
|
||||
#[$doc_link]
|
||||
pub struct $name(*mut u8);
|
||||
impl Default for $name {
|
||||
fn default() -> $name {
|
||||
$name::null()
|
||||
}
|
||||
}
|
||||
impl Handle for $name {
|
||||
const TYPE: ObjectType = ObjectType::$ty;
|
||||
fn as_raw(self) -> u64 {
|
||||
self.0 as u64
|
||||
}
|
||||
fn from_raw(x: u64) -> Self {
|
||||
$name(x as _)
|
||||
}
|
||||
}
|
||||
unsafe impl Send for $name {}
|
||||
unsafe impl Sync for $name {}
|
||||
impl $name {
|
||||
pub const fn null() -> Self {
|
||||
$name(::std::ptr::null_mut())
|
||||
}
|
||||
}
|
||||
impl fmt::Pointer for $name {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
fmt::Pointer::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
impl fmt::Debug for $name {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
fmt::Debug::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
34
ash/src/vk/platform_types.rs
Normal file
34
ash/src/vk/platform_types.rs
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
use std::os::raw::*;
|
||||
pub type RROutput = c_ulong;
|
||||
pub type VisualID = c_uint;
|
||||
pub type Display = *const c_void;
|
||||
pub type Window = c_ulong;
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type xcb_connection_t = c_void;
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type xcb_window_t = u32;
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type xcb_visualid_t = u32;
|
||||
pub type MirConnection = *const c_void;
|
||||
pub type MirSurface = *const c_void;
|
||||
pub type HINSTANCE = *const c_void;
|
||||
pub type HWND = *const c_void;
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type wl_display = c_void;
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type wl_surface = c_void;
|
||||
pub type HANDLE = *mut c_void;
|
||||
pub type HMONITOR = HANDLE;
|
||||
pub type DWORD = c_ulong;
|
||||
pub type LPCWSTR = *const u16;
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type zx_handle_t = u32;
|
||||
#[allow(non_camel_case_types)]
|
||||
pub type SECURITY_ATTRIBUTES = ();
|
||||
pub type ANativeWindow = c_void;
|
||||
pub type AHardwareBuffer = c_void;
|
||||
#[doc = r" This definition is experimental and won't adhere to semver rules."]
|
||||
pub type GgpStreamDescriptor = u32;
|
||||
#[doc = r" This definition is experimental and won't adhere to semver rules."]
|
||||
pub type GgpFrameToken = u32;
|
||||
pub type CAMetalLayer = c_void;
|
||||
|
|
@ -2,5 +2,13 @@ use generator::write_source_code;
|
|||
use std::path::Path;
|
||||
|
||||
fn main() {
|
||||
write_source_code(Path::new("Vulkan-Headers/registry/vk.xml"));
|
||||
let cwd = std::env::current_dir().unwrap();
|
||||
if cwd.ends_with("generator") {
|
||||
write_source_code(Path::new("Vulkan-Headers/registry/vk.xml"), "../ash/src");
|
||||
} else {
|
||||
write_source_code(
|
||||
Path::new("generator/Vulkan-Headers/registry/vk.xml"),
|
||||
"ash/src",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1158,7 +1158,7 @@ pub fn generate_bitmask(
|
|||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[doc = #khronos_link]
|
||||
pub struct #ident(Flags);
|
||||
pub struct #ident(pub(crate) Flags);
|
||||
vk_bitflags_wrapped!(#ident, 0b0, Flags);
|
||||
})
|
||||
}
|
||||
|
|
@ -2258,10 +2258,10 @@ pub fn generate_aliases_of_types<'a>(
|
|||
#(#aliases)*
|
||||
}
|
||||
}
|
||||
pub fn write_source_code(path: &Path) {
|
||||
pub fn write_source_code<P: AsRef<Path>>(vk_xml: &Path, src_dir: P) {
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
let spec2 = vk_parse::parse_file(path);
|
||||
let spec2 = vk_parse::parse_file(vk_xml);
|
||||
let extensions: &Vec<vk_parse::Extension> = spec2
|
||||
.0
|
||||
.iter()
|
||||
|
|
@ -2283,7 +2283,7 @@ pub fn write_source_code(path: &Path) {
|
|||
})
|
||||
.collect();
|
||||
|
||||
let spec = vk_parse::parse_file_as_vkxml(path);
|
||||
let spec = vk_parse::parse_file_as_vkxml(vk_xml);
|
||||
let cmd_aliases: HashMap<String, String> = spec2
|
||||
.0
|
||||
.iter()
|
||||
|
|
@ -2426,16 +2426,13 @@ pub fn write_source_code(path: &Path) {
|
|||
|
||||
let const_debugs = generate_const_debugs(&const_values);
|
||||
|
||||
let mut file = File::create("../ash/src/vk.rs").expect("vk");
|
||||
let bitflags_macro = vk_bitflags_wrapped_macro();
|
||||
let handle_nondispatchable_macro = handle_nondispatchable_macro();
|
||||
let define_handle_macro = define_handle_macro();
|
||||
let version_macros = vk_version_macros();
|
||||
let platform_specific_types = platform_specific_types();
|
||||
let source_code = quote! {
|
||||
#![allow(clippy::too_many_arguments, clippy::cognitive_complexity, clippy::wrong_self_convention)]
|
||||
use std::fmt;
|
||||
use std::os::raw::*;
|
||||
|
||||
let ptr_chain_code = quote! {
|
||||
/// Iterates through the pointer chain. Includes the item that is passed into the function.
|
||||
/// Stops at the last `BaseOutStructure` that has a null `p_next` field.
|
||||
pub(crate) unsafe fn ptr_chain_iter<T>(
|
||||
|
|
@ -2452,27 +2449,170 @@ pub fn write_source_code(path: &Path) {
|
|||
Some(old)
|
||||
})
|
||||
}
|
||||
};
|
||||
|
||||
let macros_code = quote! {
|
||||
#version_macros
|
||||
#bitflags_macro
|
||||
#handle_nondispatchable_macro
|
||||
#define_handle_macro
|
||||
};
|
||||
|
||||
let src_dir = src_dir.as_ref();
|
||||
|
||||
let vk_dir = src_dir.join("vk");
|
||||
std::fs::create_dir_all(&vk_dir).expect("failed to create vk dir");
|
||||
|
||||
let mut vk_rs_file = File::create(src_dir.join("vk.rs")).expect("vk.rs");
|
||||
|
||||
let mut vk_macros_file = File::create(vk_dir.join("macros.rs")).expect("vk/macros.rs");
|
||||
let mut vk_features_file = File::create(vk_dir.join("features.rs")).expect("vk/features.rs");
|
||||
let mut vk_definitions_file =
|
||||
File::create(vk_dir.join("definitions.rs")).expect("vk/definitions.rs");
|
||||
let mut vk_platform_types_file =
|
||||
File::create(vk_dir.join("platform_types.rs")).expect("vk/platform_types.rs");
|
||||
let mut vk_enums_file = File::create(vk_dir.join("enums.rs")).expect("vk/enums.rs");
|
||||
let mut vk_bitflags_file = File::create(vk_dir.join("bitflags.rs")).expect("vk/bitflags.rs");
|
||||
let mut vk_constants_file = File::create(vk_dir.join("constants.rs")).expect("vk/constants.rs");
|
||||
let mut vk_extensions_file =
|
||||
File::create(vk_dir.join("extensions.rs")).expect("vk/extensions.rs");
|
||||
let mut vk_feature_extensions_file =
|
||||
File::create(vk_dir.join("feature_extensions.rs")).expect("vk/feature_extensions.rs");
|
||||
let mut vk_const_debugs_file =
|
||||
File::create(vk_dir.join("const_debugs.rs")).expect("vk/const_debugs.rs");
|
||||
let mut vk_aliases_file = File::create(vk_dir.join("aliases.rs")).expect("vk/aliases.rs");
|
||||
|
||||
let feature_code = quote! {
|
||||
use std::os::raw::*;
|
||||
use crate::vk::bitflags::*;
|
||||
use crate::vk::definitions::*;
|
||||
use crate::vk::enums::*;
|
||||
#(#feature_code)*
|
||||
};
|
||||
|
||||
let definition_code = quote! {
|
||||
use std::fmt;
|
||||
use std::os::raw::*;
|
||||
use crate::vk::{Handle, ptr_chain_iter};
|
||||
use crate::vk::platform_types::*;
|
||||
use crate::vk::aliases::*;
|
||||
use crate::vk::bitflags::*;
|
||||
use crate::vk::constants::*;
|
||||
use crate::vk::enums::*;
|
||||
#(#definition_code)*
|
||||
};
|
||||
|
||||
let enum_code = quote! {
|
||||
use std::fmt;
|
||||
#(#enum_code)*
|
||||
};
|
||||
|
||||
let bitflags_code = quote! {
|
||||
use crate::vk::definitions::*;
|
||||
#(#bitflags_code)*
|
||||
};
|
||||
|
||||
let constants_code = quote! {
|
||||
use crate::vk::definitions::*;
|
||||
#(#constants_code)*
|
||||
};
|
||||
|
||||
let extension_code = quote! {
|
||||
use std::os::raw::*;
|
||||
use crate::vk::platform_types::*;
|
||||
use crate::vk::aliases::*;
|
||||
use crate::vk::bitflags::*;
|
||||
use crate::vk::definitions::*;
|
||||
use crate::vk::enums::*;
|
||||
#(#extension_code)*
|
||||
};
|
||||
|
||||
let feature_extensions_code = quote! {
|
||||
use crate::vk::bitflags::*;
|
||||
use crate::vk::enums::*;
|
||||
#feature_extensions_code
|
||||
};
|
||||
|
||||
let const_debugs = quote! {
|
||||
use std::fmt;
|
||||
use crate::vk::bitflags::*;
|
||||
use crate::vk::definitions::*;
|
||||
use crate::vk::enums::*;
|
||||
#const_debugs
|
||||
};
|
||||
|
||||
let aliases = quote! {
|
||||
use crate::vk::bitflags::*;
|
||||
use crate::vk::definitions::*;
|
||||
use crate::vk::enums::*;
|
||||
#(#aliases)*
|
||||
};
|
||||
|
||||
let platform_types_code = quote! {
|
||||
use std::os::raw::*;
|
||||
#platform_specific_types
|
||||
};
|
||||
|
||||
// These are defined outside of `quote!` because rustfmt doesn't seem
|
||||
// to format them correctly when they contain extra spaces.
|
||||
let vk_rs_clippy_lints = r#"
|
||||
#![allow(clippy::too_many_arguments, clippy::cognitive_complexity, clippy::wrong_self_convention)]
|
||||
"#;
|
||||
|
||||
let vk_rs_code = quote! {
|
||||
#[macro_use]
|
||||
mod macros;
|
||||
pub use macros::*;
|
||||
mod aliases;
|
||||
pub use aliases::*;
|
||||
mod bitflags;
|
||||
pub use bitflags::*;
|
||||
mod const_debugs;
|
||||
pub(crate) use const_debugs::*;
|
||||
mod constants;
|
||||
pub use constants::*;
|
||||
mod definitions;
|
||||
pub use definitions::*;
|
||||
mod enums;
|
||||
pub use enums::*;
|
||||
mod extensions;
|
||||
pub use extensions::*;
|
||||
mod feature_extensions;
|
||||
pub use feature_extensions::*;
|
||||
mod features;
|
||||
pub use features::*;
|
||||
mod platform_types;
|
||||
pub use platform_types::*;
|
||||
|
||||
#ptr_chain_code
|
||||
|
||||
pub trait Handle {
|
||||
const TYPE: ObjectType;
|
||||
fn as_raw(self) -> u64;
|
||||
fn from_raw(_: u64) -> Self;
|
||||
}
|
||||
|
||||
#version_macros
|
||||
#platform_specific_types
|
||||
#bitflags_macro
|
||||
#handle_nondispatchable_macro
|
||||
#define_handle_macro
|
||||
#(#feature_code)*
|
||||
#(#definition_code)*
|
||||
#(#enum_code)*
|
||||
#(#bitflags_code)*
|
||||
#(#constants_code)*
|
||||
#(#extension_code)*
|
||||
#feature_extensions_code
|
||||
#const_debugs
|
||||
#(#aliases)*
|
||||
};
|
||||
write!(&mut file, "{}", source_code).expect("Unable to write to file");
|
||||
|
||||
write!(&mut vk_macros_file, "{}", macros_code).expect("Unable to write vk/macros.rs");
|
||||
write!(&mut vk_platform_types_file, "{}", platform_types_code)
|
||||
.expect("Unable to write to vk/platform_types.rs");
|
||||
write!(&mut vk_features_file, "{}", feature_code).expect("Unable to write vk/features.rs");
|
||||
write!(&mut vk_definitions_file, "{}", definition_code)
|
||||
.expect("Unable to write vk/definitions.rs");
|
||||
write!(&mut vk_enums_file, "{}", enum_code).expect("Unable to write vk/enums.rs");
|
||||
write!(&mut vk_bitflags_file, "{}", bitflags_code).expect("Unable to write vk/bitflags.rs");
|
||||
write!(&mut vk_constants_file, "{}", constants_code).expect("Unable to write vk/constants.rs");
|
||||
write!(&mut vk_extensions_file, "{}", extension_code)
|
||||
.expect("Unable to write vk/extensions.rs");
|
||||
write!(
|
||||
&mut vk_feature_extensions_file,
|
||||
"{}",
|
||||
feature_extensions_code
|
||||
)
|
||||
.expect("Unable to write vk/feature_extensions.rs");
|
||||
write!(&mut vk_const_debugs_file, "{}", const_debugs)
|
||||
.expect("Unable to write vk/const_debugs.rs");
|
||||
write!(&mut vk_aliases_file, "{}", aliases).expect("Unable to write vk/aliases.rs");
|
||||
write!(&mut vk_rs_file, "{} {}", vk_rs_clippy_lints, vk_rs_code)
|
||||
.expect("Unable to write vk.rs");
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue