1 use crate::vk::definitions::*; 2 #[repr(transparent)] 3 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 4 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateFlagBits.html>"] 5 pub struct PipelineCacheCreateFlags(pub(crate) Flags); 6 vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags); 7 impl PipelineCacheCreateFlags {} 8 #[repr(transparent)] 9 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 10 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFlagBits.html>"] 11 pub struct QueueFlags(pub(crate) Flags); 12 vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); 13 impl QueueFlags { 14 #[doc = "Queue supports graphics operations"] 15 pub const GRAPHICS: Self = Self(0b1); 16 #[doc = "Queue supports compute operations"] 17 pub const COMPUTE: Self = Self(0b10); 18 #[doc = "Queue supports transfer operations"] 19 pub const TRANSFER: Self = Self(0b100); 20 #[doc = "Queue supports sparse resource memory management operations"] 21 pub const SPARSE_BINDING: Self = Self(0b1000); 22 } 23 #[repr(transparent)] 24 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 25 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCullModeFlagBits.html>"] 26 pub struct CullModeFlags(pub(crate) Flags); 27 vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); 28 impl CullModeFlags { 29 pub const NONE: Self = Self(0); 30 pub const FRONT: Self = Self(0b1); 31 pub const BACK: Self = Self(0b10); 32 pub const FRONT_AND_BACK: Self = Self(0x0000_0003); 33 } 34 #[repr(transparent)] 35 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 36 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateFlagBits.html>"] 37 pub struct RenderPassCreateFlags(pub(crate) Flags); 38 vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags); 39 impl RenderPassCreateFlags {} 40 #[repr(transparent)] 41 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 42 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateFlagBits.html>"] 43 pub struct DeviceQueueCreateFlags(pub(crate) Flags); 44 vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); 45 impl DeviceQueueCreateFlags {} 46 #[repr(transparent)] 47 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 48 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPropertyFlagBits.html>"] 49 pub struct MemoryPropertyFlags(pub(crate) Flags); 50 vk_bitflags_wrapped!(MemoryPropertyFlags, 0b1_1111, Flags); 51 impl MemoryPropertyFlags { 52 #[doc = "If otherwise stated, then allocate memory on device"] 53 pub const DEVICE_LOCAL: Self = Self(0b1); 54 #[doc = "Memory is mappable by host"] 55 pub const HOST_VISIBLE: Self = Self(0b10); 56 #[doc = "Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"] 57 pub const HOST_COHERENT: Self = Self(0b100); 58 #[doc = "Memory will be cached by the host"] 59 pub const HOST_CACHED: Self = Self(0b1000); 60 #[doc = "Memory may be allocated by the driver when it is required"] 61 pub const LAZILY_ALLOCATED: Self = Self(0b1_0000); 62 } 63 #[repr(transparent)] 64 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 65 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeapFlagBits.html>"] 66 pub struct MemoryHeapFlags(pub(crate) Flags); 67 vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); 68 impl MemoryHeapFlags { 69 #[doc = "If set, heap represents device memory"] 70 pub const DEVICE_LOCAL: Self = Self(0b1); 71 } 72 #[repr(transparent)] 73 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 74 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits.html>"] 75 pub struct AccessFlags(pub(crate) Flags); 76 vk_bitflags_wrapped!(AccessFlags, 0b1_1111_1111_1111_1111, Flags); 77 impl AccessFlags { 78 #[doc = "Controls coherency of indirect command reads"] 79 pub const INDIRECT_COMMAND_READ: Self = Self(0b1); 80 #[doc = "Controls coherency of index reads"] 81 pub const INDEX_READ: Self = Self(0b10); 82 #[doc = "Controls coherency of vertex attribute reads"] 83 pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100); 84 #[doc = "Controls coherency of uniform buffer reads"] 85 pub const UNIFORM_READ: Self = Self(0b1000); 86 #[doc = "Controls coherency of input attachment reads"] 87 pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000); 88 #[doc = "Controls coherency of shader reads"] 89 pub const SHADER_READ: Self = Self(0b10_0000); 90 #[doc = "Controls coherency of shader writes"] 91 pub const SHADER_WRITE: Self = Self(0b100_0000); 92 #[doc = "Controls coherency of color attachment reads"] 93 pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000); 94 #[doc = "Controls coherency of color attachment writes"] 95 pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000); 96 #[doc = "Controls coherency of depth/stencil attachment reads"] 97 pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000); 98 #[doc = "Controls coherency of depth/stencil attachment writes"] 99 pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000); 100 #[doc = "Controls coherency of transfer reads"] 101 pub const TRANSFER_READ: Self = Self(0b1000_0000_0000); 102 #[doc = "Controls coherency of transfer writes"] 103 pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000); 104 #[doc = "Controls coherency of host reads"] 105 pub const HOST_READ: Self = Self(0b10_0000_0000_0000); 106 #[doc = "Controls coherency of host writes"] 107 pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000); 108 #[doc = "Controls coherency of memory reads"] 109 pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000); 110 #[doc = "Controls coherency of memory writes"] 111 pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000); 112 } 113 #[repr(transparent)] 114 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 115 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferUsageFlagBits.html>"] 116 pub struct BufferUsageFlags(pub(crate) Flags); 117 vk_bitflags_wrapped!(BufferUsageFlags, 0b1_1111_1111, Flags); 118 impl BufferUsageFlags { 119 #[doc = "Can be used as a source of transfer operations"] 120 pub const TRANSFER_SRC: Self = Self(0b1); 121 #[doc = "Can be used as a destination of transfer operations"] 122 pub const TRANSFER_DST: Self = Self(0b10); 123 #[doc = "Can be used as TBO"] 124 pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b100); 125 #[doc = "Can be used as IBO"] 126 pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1000); 127 #[doc = "Can be used as UBO"] 128 pub const UNIFORM_BUFFER: Self = Self(0b1_0000); 129 #[doc = "Can be used as SSBO"] 130 pub const STORAGE_BUFFER: Self = Self(0b10_0000); 131 #[doc = "Can be used as source of fixed-function index fetch (index buffer)"] 132 pub const INDEX_BUFFER: Self = Self(0b100_0000); 133 #[doc = "Can be used as source of fixed-function vertex fetch (VBO)"] 134 pub const VERTEX_BUFFER: Self = Self(0b1000_0000); 135 #[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"] 136 pub const INDIRECT_BUFFER: Self = Self(0b1_0000_0000); 137 } 138 #[repr(transparent)] 139 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 140 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateFlagBits.html>"] 141 pub struct BufferCreateFlags(pub(crate) Flags); 142 vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); 143 impl BufferCreateFlags { 144 #[doc = "Buffer should support sparse backing"] 145 pub const SPARSE_BINDING: Self = Self(0b1); 146 #[doc = "Buffer should support sparse backing with partial residency"] 147 pub const SPARSE_RESIDENCY: Self = Self(0b10); 148 #[doc = "Buffer should support constant data access to physical memory ranges mapped into multiple locations of sparse buffers"] 149 pub const SPARSE_ALIASED: Self = Self(0b100); 150 } 151 #[repr(transparent)] 152 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 153 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStageFlagBits.html>"] 154 pub struct ShaderStageFlags(pub(crate) Flags); 155 vk_bitflags_wrapped!( 156 ShaderStageFlags, 157 0b111_1111_1111_1111_1111_1111_1111_1111, 158 Flags 159 ); 160 impl ShaderStageFlags { 161 pub const VERTEX: Self = Self(0b1); 162 pub const TESSELLATION_CONTROL: Self = Self(0b10); 163 pub const TESSELLATION_EVALUATION: Self = Self(0b100); 164 pub const GEOMETRY: Self = Self(0b1000); 165 pub const FRAGMENT: Self = Self(0b1_0000); 166 pub const COMPUTE: Self = Self(0b10_0000); 167 pub const ALL_GRAPHICS: Self = Self(0x0000_001F); 168 pub const ALL: Self = Self(0x7FFF_FFFF); 169 } 170 #[repr(transparent)] 171 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 172 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageUsageFlagBits.html>"] 173 pub struct ImageUsageFlags(pub(crate) Flags); 174 vk_bitflags_wrapped!(ImageUsageFlags, 0b1111_1111, Flags); 175 impl ImageUsageFlags { 176 #[doc = "Can be used as a source of transfer operations"] 177 pub const TRANSFER_SRC: Self = Self(0b1); 178 #[doc = "Can be used as a destination of transfer operations"] 179 pub const TRANSFER_DST: Self = Self(0b10); 180 #[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] 181 pub const SAMPLED: Self = Self(0b100); 182 #[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"] 183 pub const STORAGE: Self = Self(0b1000); 184 #[doc = "Can be used as framebuffer color attachment"] 185 pub const COLOR_ATTACHMENT: Self = Self(0b1_0000); 186 #[doc = "Can be used as framebuffer depth/stencil attachment"] 187 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000); 188 #[doc = "Image data not needed outside of rendering"] 189 pub const TRANSIENT_ATTACHMENT: Self = Self(0b100_0000); 190 #[doc = "Can be used as framebuffer input attachment"] 191 pub const INPUT_ATTACHMENT: Self = Self(0b1000_0000); 192 } 193 #[repr(transparent)] 194 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 195 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateFlagBits.html>"] 196 pub struct ImageCreateFlags(pub(crate) Flags); 197 vk_bitflags_wrapped!(ImageCreateFlags, 0b1_1111, Flags); 198 impl ImageCreateFlags { 199 #[doc = "Image should support sparse backing"] 200 pub const SPARSE_BINDING: Self = Self(0b1); 201 #[doc = "Image should support sparse backing with partial residency"] 202 pub const SPARSE_RESIDENCY: Self = Self(0b10); 203 #[doc = "Image should support constant data access to physical memory ranges mapped into multiple locations of sparse images"] 204 pub const SPARSE_ALIASED: Self = Self(0b100); 205 #[doc = "Allows image views to have different format than the base image"] 206 pub const MUTABLE_FORMAT: Self = Self(0b1000); 207 #[doc = "Allows creating image views with cube type from the created image"] 208 pub const CUBE_COMPATIBLE: Self = Self(0b1_0000); 209 } 210 #[repr(transparent)] 211 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 212 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateFlagBits.html>"] 213 pub struct ImageViewCreateFlags(pub(crate) Flags); 214 vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags); 215 impl ImageViewCreateFlags {} 216 #[repr(transparent)] 217 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 218 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateFlagBits.html>"] 219 pub struct SamplerCreateFlags(pub(crate) Flags); 220 vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags); 221 impl SamplerCreateFlags {} 222 #[repr(transparent)] 223 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 224 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreateFlagBits.html>"] 225 pub struct PipelineCreateFlags(pub(crate) Flags); 226 vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); 227 impl PipelineCreateFlags { 228 pub const DISABLE_OPTIMIZATION: Self = Self(0b1); 229 pub const ALLOW_DERIVATIVES: Self = Self(0b10); 230 pub const DERIVATIVE: Self = Self(0b100); 231 } 232 #[repr(transparent)] 233 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 234 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateFlagBits.html>"] 235 pub struct PipelineShaderStageCreateFlags(pub(crate) Flags); 236 vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags); 237 impl PipelineShaderStageCreateFlags {} 238 #[repr(transparent)] 239 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 240 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkColorComponentFlagBits.html>"] 241 pub struct ColorComponentFlags(pub(crate) Flags); 242 vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); 243 impl ColorComponentFlags { 244 pub const R: Self = Self(0b1); 245 pub const G: Self = Self(0b10); 246 pub const B: Self = Self(0b100); 247 pub const A: Self = Self(0b1000); 248 } 249 #[repr(transparent)] 250 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 251 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateFlagBits.html>"] 252 pub struct FenceCreateFlags(pub(crate) Flags); 253 vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); 254 impl FenceCreateFlags { 255 pub const SIGNALED: Self = Self(0b1); 256 } 257 #[repr(transparent)] 258 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 259 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateFlagBits.html>"] 260 pub struct SemaphoreCreateFlags(pub(crate) Flags); 261 vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); 262 impl SemaphoreCreateFlags {} 263 #[repr(transparent)] 264 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 265 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits.html>"] 266 pub struct FormatFeatureFlags(pub(crate) Flags); 267 vk_bitflags_wrapped!(FormatFeatureFlags, 0b1_1111_1111_1111, Flags); 268 impl FormatFeatureFlags { 269 #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] 270 pub const SAMPLED_IMAGE: Self = Self(0b1); 271 #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"] 272 pub const STORAGE_IMAGE: Self = Self(0b10); 273 #[doc = "Format supports atomic operations in case it is used for storage images"] 274 pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); 275 #[doc = "Format can be used for uniform texel buffers (TBOs)"] 276 pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); 277 #[doc = "Format can be used for storage texel buffers (IBOs)"] 278 pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); 279 #[doc = "Format supports atomic operations in case it is used for storage texel buffers"] 280 pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); 281 #[doc = "Format can be used for vertex buffers (VBOs)"] 282 pub const VERTEX_BUFFER: Self = Self(0b100_0000); 283 #[doc = "Format can be used for color attachment images"] 284 pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); 285 #[doc = "Format supports blending in case it is used for color attachment images"] 286 pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); 287 #[doc = "Format can be used for depth/stencil attachment images"] 288 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); 289 #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"] 290 pub const BLIT_SRC: Self = Self(0b100_0000_0000); 291 #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"] 292 pub const BLIT_DST: Self = Self(0b1000_0000_0000); 293 #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] 294 pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); 295 } 296 #[repr(transparent)] 297 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 298 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryControlFlagBits.html>"] 299 pub struct QueryControlFlags(pub(crate) Flags); 300 vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); 301 impl QueryControlFlags { 302 #[doc = "Require precise results to be collected by the query"] 303 pub const PRECISE: Self = Self(0b1); 304 } 305 #[repr(transparent)] 306 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 307 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryResultFlagBits.html>"] 308 pub struct QueryResultFlags(pub(crate) Flags); 309 vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); 310 impl QueryResultFlags { 311 #[doc = "Results of the queries are written to the destination buffer as 64-bit values"] 312 pub const TYPE_64: Self = Self(0b1); 313 #[doc = "Results of the queries are waited on before proceeding with the result copy"] 314 pub const WAIT: Self = Self(0b10); 315 #[doc = "Besides the results of the query, the availability of the results is also written"] 316 pub const WITH_AVAILABILITY: Self = Self(0b100); 317 #[doc = "Copy the partial results of the query even if the final results are not available"] 318 pub const PARTIAL: Self = Self(0b1000); 319 } 320 #[repr(transparent)] 321 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 322 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferUsageFlagBits.html>"] 323 pub struct CommandBufferUsageFlags(pub(crate) Flags); 324 vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); 325 impl CommandBufferUsageFlags { 326 pub const ONE_TIME_SUBMIT: Self = Self(0b1); 327 pub const RENDER_PASS_CONTINUE: Self = Self(0b10); 328 #[doc = "Command buffer may be submitted/executed more than once simultaneously"] 329 pub const SIMULTANEOUS_USE: Self = Self(0b100); 330 } 331 #[repr(transparent)] 332 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 333 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"] 334 pub struct QueryPipelineStatisticFlags(pub(crate) Flags); 335 vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b111_1111_1111, Flags); 336 impl QueryPipelineStatisticFlags { 337 #[doc = "Optional"] 338 pub const INPUT_ASSEMBLY_VERTICES: Self = Self(0b1); 339 #[doc = "Optional"] 340 pub const INPUT_ASSEMBLY_PRIMITIVES: Self = Self(0b10); 341 #[doc = "Optional"] 342 pub const VERTEX_SHADER_INVOCATIONS: Self = Self(0b100); 343 #[doc = "Optional"] 344 pub const GEOMETRY_SHADER_INVOCATIONS: Self = Self(0b1000); 345 #[doc = "Optional"] 346 pub const GEOMETRY_SHADER_PRIMITIVES: Self = Self(0b1_0000); 347 #[doc = "Optional"] 348 pub const CLIPPING_INVOCATIONS: Self = Self(0b10_0000); 349 #[doc = "Optional"] 350 pub const CLIPPING_PRIMITIVES: Self = Self(0b100_0000); 351 #[doc = "Optional"] 352 pub const FRAGMENT_SHADER_INVOCATIONS: Self = Self(0b1000_0000); 353 #[doc = "Optional"] 354 pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = Self(0b1_0000_0000); 355 #[doc = "Optional"] 356 pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = Self(0b10_0000_0000); 357 #[doc = "Optional"] 358 pub const COMPUTE_SHADER_INVOCATIONS: Self = Self(0b100_0000_0000); 359 } 360 #[repr(transparent)] 361 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 362 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageAspectFlagBits.html>"] 363 pub struct ImageAspectFlags(pub(crate) Flags); 364 vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); 365 impl ImageAspectFlags { 366 pub const COLOR: Self = Self(0b1); 367 pub const DEPTH: Self = Self(0b10); 368 pub const STENCIL: Self = Self(0b100); 369 pub const METADATA: Self = Self(0b1000); 370 } 371 #[repr(transparent)] 372 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 373 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatFlagBits.html>"] 374 pub struct SparseImageFormatFlags(pub(crate) Flags); 375 vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); 376 impl SparseImageFormatFlags { 377 #[doc = "Image uses a single mip tail region for all array layers"] 378 pub const SINGLE_MIPTAIL: Self = Self(0b1); 379 #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."] 380 pub const ALIGNED_MIP_SIZE: Self = Self(0b10); 381 #[doc = "Image uses a non-standard sparse image block dimensions"] 382 pub const NONSTANDARD_BLOCK_SIZE: Self = Self(0b100); 383 } 384 #[repr(transparent)] 385 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 386 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBindFlagBits.html>"] 387 pub struct SparseMemoryBindFlags(pub(crate) Flags); 388 vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); 389 impl SparseMemoryBindFlags { 390 #[doc = "Operation binds resource metadata to memory"] 391 pub const METADATA: Self = Self(0b1); 392 } 393 #[repr(transparent)] 394 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 395 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits.html>"] 396 pub struct PipelineStageFlags(pub(crate) Flags); 397 vk_bitflags_wrapped!(PipelineStageFlags, 0b1_1111_1111_1111_1111, Flags); 398 impl PipelineStageFlags { 399 #[doc = "Before subsequent commands are processed"] 400 pub const TOP_OF_PIPE: Self = Self(0b1); 401 #[doc = "Draw/DispatchIndirect command fetch"] 402 pub const DRAW_INDIRECT: Self = Self(0b10); 403 #[doc = "Vertex/index fetch"] 404 pub const VERTEX_INPUT: Self = Self(0b100); 405 #[doc = "Vertex shading"] 406 pub const VERTEX_SHADER: Self = Self(0b1000); 407 #[doc = "Tessellation control shading"] 408 pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); 409 #[doc = "Tessellation evaluation shading"] 410 pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); 411 #[doc = "Geometry shading"] 412 pub const GEOMETRY_SHADER: Self = Self(0b100_0000); 413 #[doc = "Fragment shading"] 414 pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); 415 #[doc = "Early fragment (depth and stencil) tests"] 416 pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); 417 #[doc = "Late fragment (depth and stencil) tests"] 418 pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); 419 #[doc = "Color attachment writes"] 420 pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); 421 #[doc = "Compute shading"] 422 pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); 423 #[doc = "Transfer/copy operations"] 424 pub const TRANSFER: Self = Self(0b1_0000_0000_0000); 425 #[doc = "After previous commands have completed"] 426 pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); 427 #[doc = "Indicates host (CPU) is a source/sink of the dependency"] 428 pub const HOST: Self = Self(0b100_0000_0000_0000); 429 #[doc = "All stages of the graphics pipeline"] 430 pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); 431 #[doc = "All stages supported on the queue"] 432 pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); 433 } 434 #[repr(transparent)] 435 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 436 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateFlagBits.html>"] 437 pub struct CommandPoolCreateFlags(pub(crate) Flags); 438 vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); 439 impl CommandPoolCreateFlags { 440 #[doc = "Command buffers have a short lifetime"] 441 pub const TRANSIENT: Self = Self(0b1); 442 #[doc = "Command buffers may release their memory individually"] 443 pub const RESET_COMMAND_BUFFER: Self = Self(0b10); 444 } 445 #[repr(transparent)] 446 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 447 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolResetFlagBits.html>"] 448 pub struct CommandPoolResetFlags(pub(crate) Flags); 449 vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); 450 impl CommandPoolResetFlags { 451 #[doc = "Release resources owned by the pool"] 452 pub const RELEASE_RESOURCES: Self = Self(0b1); 453 } 454 #[repr(transparent)] 455 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 456 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferResetFlagBits.html>"] 457 pub struct CommandBufferResetFlags(pub(crate) Flags); 458 vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); 459 impl CommandBufferResetFlags { 460 #[doc = "Release resources owned by the buffer"] 461 pub const RELEASE_RESOURCES: Self = Self(0b1); 462 } 463 #[repr(transparent)] 464 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 465 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleCountFlagBits.html>"] 466 pub struct SampleCountFlags(pub(crate) Flags); 467 vk_bitflags_wrapped!(SampleCountFlags, 0b111_1111, Flags); 468 impl SampleCountFlags { 469 #[doc = "Sample count 1 supported"] 470 pub const TYPE_1: Self = Self(0b1); 471 #[doc = "Sample count 2 supported"] 472 pub const TYPE_2: Self = Self(0b10); 473 #[doc = "Sample count 4 supported"] 474 pub const TYPE_4: Self = Self(0b100); 475 #[doc = "Sample count 8 supported"] 476 pub const TYPE_8: Self = Self(0b1000); 477 #[doc = "Sample count 16 supported"] 478 pub const TYPE_16: Self = Self(0b1_0000); 479 #[doc = "Sample count 32 supported"] 480 pub const TYPE_32: Self = Self(0b10_0000); 481 #[doc = "Sample count 64 supported"] 482 pub const TYPE_64: Self = Self(0b100_0000); 483 } 484 #[repr(transparent)] 485 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 486 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"] 487 pub struct AttachmentDescriptionFlags(pub(crate) Flags); 488 vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); 489 impl AttachmentDescriptionFlags { 490 #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] 491 pub const MAY_ALIAS: Self = Self(0b1); 492 } 493 #[repr(transparent)] 494 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 495 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilFaceFlagBits.html>"] 496 pub struct StencilFaceFlags(pub(crate) Flags); 497 vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); 498 impl StencilFaceFlags { 499 #[doc = "Front face"] 500 pub const FRONT: Self = Self(0b1); 501 #[doc = "Back face"] 502 pub const BACK: Self = Self(0b10); 503 #[doc = "Front and back faces"] 504 pub const FRONT_AND_BACK: Self = Self(0x0000_0003); 505 #[deprecated = "Alias for backwards compatibility"] 506 pub const STENCIL_FRONT_AND_BACK: Self = Self::FRONT_AND_BACK; 507 } 508 #[repr(transparent)] 509 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 510 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"] 511 pub struct DescriptorPoolCreateFlags(pub(crate) Flags); 512 vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); 513 impl DescriptorPoolCreateFlags { 514 #[doc = "Descriptor sets may be freed individually"] 515 pub const FREE_DESCRIPTOR_SET: Self = Self(0b1); 516 } 517 #[repr(transparent)] 518 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 519 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDependencyFlagBits.html>"] 520 pub struct DependencyFlags(pub(crate) Flags); 521 vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); 522 impl DependencyFlags { 523 #[doc = "Dependency is per pixel region "] 524 pub const BY_REGION: Self = Self(0b1); 525 } 526 #[repr(transparent)] 527 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 528 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitFlagBits.html>"] 529 pub struct SemaphoreWaitFlags(pub(crate) Flags); 530 vk_bitflags_wrapped!(SemaphoreWaitFlags, 0b1, Flags); 531 impl SemaphoreWaitFlags { 532 pub const ANY: Self = Self(0b1); 533 } 534 #[repr(transparent)] 535 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 536 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html>"] 537 pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); 538 vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); 539 impl DisplayPlaneAlphaFlagsKHR { 540 pub const OPAQUE: Self = Self(0b1); 541 pub const GLOBAL: Self = Self(0b10); 542 pub const PER_PIXEL: Self = Self(0b100); 543 pub const PER_PIXEL_PREMULTIPLIED: Self = Self(0b1000); 544 } 545 #[repr(transparent)] 546 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 547 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"] 548 pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); 549 vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); 550 impl CompositeAlphaFlagsKHR { 551 pub const OPAQUE: Self = Self(0b1); 552 pub const PRE_MULTIPLIED: Self = Self(0b10); 553 pub const POST_MULTIPLIED: Self = Self(0b100); 554 pub const INHERIT: Self = Self(0b1000); 555 } 556 #[repr(transparent)] 557 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 558 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"] 559 pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); 560 vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b1_1111_1111, Flags); 561 impl SurfaceTransformFlagsKHR { 562 pub const IDENTITY: Self = Self(0b1); 563 pub const ROTATE_90: Self = Self(0b10); 564 pub const ROTATE_180: Self = Self(0b100); 565 pub const ROTATE_270: Self = Self(0b1000); 566 pub const HORIZONTAL_MIRROR: Self = Self(0b1_0000); 567 pub const HORIZONTAL_MIRROR_ROTATE_90: Self = Self(0b10_0000); 568 pub const HORIZONTAL_MIRROR_ROTATE_180: Self = Self(0b100_0000); 569 pub const HORIZONTAL_MIRROR_ROTATE_270: Self = Self(0b1000_0000); 570 pub const INHERIT: Self = Self(0b1_0000_0000); 571 } 572 #[repr(transparent)] 573 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 574 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"] 575 pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags); 576 vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, 0b1, Flags); 577 impl SwapchainImageUsageFlagsANDROID { 578 pub const SHARED: Self = Self(0b1); 579 } 580 #[repr(transparent)] 581 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 582 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportFlagBitsEXT.html>"] 583 pub struct DebugReportFlagsEXT(pub(crate) Flags); 584 vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b1_1111, Flags); 585 impl DebugReportFlagsEXT { 586 pub const INFORMATION: Self = Self(0b1); 587 pub const WARNING: Self = Self(0b10); 588 pub const PERFORMANCE_WARNING: Self = Self(0b100); 589 pub const ERROR: Self = Self(0b1000); 590 pub const DEBUG: Self = Self(0b1_0000); 591 } 592 #[repr(transparent)] 593 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 594 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"] 595 pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); 596 vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); 597 impl ExternalMemoryHandleTypeFlagsNV { 598 pub const OPAQUE_WIN32: Self = Self(0b1); 599 pub const OPAQUE_WIN32_KMT: Self = Self(0b10); 600 pub const D3D11_IMAGE: Self = Self(0b100); 601 pub const D3D11_IMAGE_KMT: Self = Self(0b1000); 602 } 603 #[repr(transparent)] 604 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 605 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"] 606 pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); 607 vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); 608 impl ExternalMemoryFeatureFlagsNV { 609 pub const DEDICATED_ONLY: Self = Self(0b1); 610 pub const EXPORTABLE: Self = Self(0b10); 611 pub const IMPORTABLE: Self = Self(0b100); 612 } 613 #[repr(transparent)] 614 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 615 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubgroupFeatureFlagBits.html>"] 616 pub struct SubgroupFeatureFlags(pub(crate) Flags); 617 vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b1111_1111, Flags); 618 impl SubgroupFeatureFlags { 619 #[doc = "Basic subgroup operations"] 620 pub const BASIC: Self = Self(0b1); 621 #[doc = "Vote subgroup operations"] 622 pub const VOTE: Self = Self(0b10); 623 #[doc = "Arithmetic subgroup operations"] 624 pub const ARITHMETIC: Self = Self(0b100); 625 #[doc = "Ballot subgroup operations"] 626 pub const BALLOT: Self = Self(0b1000); 627 #[doc = "Shuffle subgroup operations"] 628 pub const SHUFFLE: Self = Self(0b1_0000); 629 #[doc = "Shuffle relative subgroup operations"] 630 pub const SHUFFLE_RELATIVE: Self = Self(0b10_0000); 631 #[doc = "Clustered subgroup operations"] 632 pub const CLUSTERED: Self = Self(0b100_0000); 633 #[doc = "Quad subgroup operations"] 634 pub const QUAD: Self = Self(0b1000_0000); 635 } 636 #[repr(transparent)] 637 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 638 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"] 639 pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags); 640 vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, 0b111, Flags); 641 impl IndirectCommandsLayoutUsageFlagsNV { 642 pub const EXPLICIT_PREPROCESS: Self = Self(0b1); 643 pub const INDEXED_SEQUENCES: Self = Self(0b10); 644 pub const UNORDERED_SEQUENCES: Self = Self(0b100); 645 } 646 #[repr(transparent)] 647 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 648 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagBitsNV.html>"] 649 pub struct IndirectStateFlagsNV(pub(crate) Flags); 650 vk_bitflags_wrapped!(IndirectStateFlagsNV, 0b1, Flags); 651 impl IndirectStateFlagsNV { 652 pub const FLAG_FRONTFACE: Self = Self(0b1); 653 } 654 #[repr(transparent)] 655 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 656 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrivateDataSlotCreateFlagBitsEXT.html>"] 657 pub struct PrivateDataSlotCreateFlagsEXT(pub(crate) Flags); 658 vk_bitflags_wrapped!(PrivateDataSlotCreateFlagsEXT, 0b0, Flags); 659 impl PrivateDataSlotCreateFlagsEXT {} 660 #[repr(transparent)] 661 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 662 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"] 663 pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); 664 vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); 665 impl DescriptorSetLayoutCreateFlags {} 666 #[repr(transparent)] 667 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 668 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"] 669 pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); 670 vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b111_1111, Flags); 671 impl ExternalMemoryHandleTypeFlags { 672 pub const OPAQUE_FD: Self = Self(0b1); 673 pub const OPAQUE_WIN32: Self = Self(0b10); 674 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 675 pub const D3D11_TEXTURE: Self = Self(0b1000); 676 pub const D3D11_TEXTURE_KMT: Self = Self(0b1_0000); 677 pub const D3D12_HEAP: Self = Self(0b10_0000); 678 pub const D3D12_RESOURCE: Self = Self(0b100_0000); 679 } 680 #[repr(transparent)] 681 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 682 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"] 683 pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); 684 vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); 685 impl ExternalMemoryFeatureFlags { 686 pub const DEDICATED_ONLY: Self = Self(0b1); 687 pub const EXPORTABLE: Self = Self(0b10); 688 pub const IMPORTABLE: Self = Self(0b100); 689 } 690 #[repr(transparent)] 691 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 692 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"] 693 pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); 694 vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b1_1111, Flags); 695 impl ExternalSemaphoreHandleTypeFlags { 696 pub const OPAQUE_FD: Self = Self(0b1); 697 pub const OPAQUE_WIN32: Self = Self(0b10); 698 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 699 pub const D3D12_FENCE: Self = Self(0b1000); 700 pub const D3D11_FENCE: Self = Self::D3D12_FENCE; 701 pub const SYNC_FD: Self = Self(0b1_0000); 702 } 703 #[repr(transparent)] 704 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 705 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"] 706 pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); 707 vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); 708 impl ExternalSemaphoreFeatureFlags { 709 pub const EXPORTABLE: Self = Self(0b1); 710 pub const IMPORTABLE: Self = Self(0b10); 711 } 712 #[repr(transparent)] 713 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 714 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreImportFlagBits.html>"] 715 pub struct SemaphoreImportFlags(pub(crate) Flags); 716 vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); 717 impl SemaphoreImportFlags { 718 pub const TEMPORARY: Self = Self(0b1); 719 } 720 #[repr(transparent)] 721 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 722 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"] 723 pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); 724 vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); 725 impl ExternalFenceHandleTypeFlags { 726 pub const OPAQUE_FD: Self = Self(0b1); 727 pub const OPAQUE_WIN32: Self = Self(0b10); 728 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 729 pub const SYNC_FD: Self = Self(0b1000); 730 } 731 #[repr(transparent)] 732 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 733 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"] 734 pub struct ExternalFenceFeatureFlags(pub(crate) Flags); 735 vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); 736 impl ExternalFenceFeatureFlags { 737 pub const EXPORTABLE: Self = Self(0b1); 738 pub const IMPORTABLE: Self = Self(0b10); 739 } 740 #[repr(transparent)] 741 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 742 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceImportFlagBits.html>"] 743 pub struct FenceImportFlags(pub(crate) Flags); 744 vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); 745 impl FenceImportFlags { 746 pub const TEMPORARY: Self = Self(0b1); 747 } 748 #[repr(transparent)] 749 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 750 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"] 751 pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); 752 vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); 753 impl SurfaceCounterFlagsEXT { 754 pub const VBLANK: Self = Self(0b1); 755 } 756 #[repr(transparent)] 757 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 758 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"] 759 pub struct PeerMemoryFeatureFlags(pub(crate) Flags); 760 vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); 761 impl PeerMemoryFeatureFlags { 762 #[doc = "Can read with vkCmdCopy commands"] 763 pub const COPY_SRC: Self = Self(0b1); 764 #[doc = "Can write with vkCmdCopy commands"] 765 pub const COPY_DST: Self = Self(0b10); 766 #[doc = "Can read with any access type/command"] 767 pub const GENERIC_SRC: Self = Self(0b100); 768 #[doc = "Can write with and access type/command"] 769 pub const GENERIC_DST: Self = Self(0b1000); 770 } 771 #[repr(transparent)] 772 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 773 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagBits.html>"] 774 pub struct MemoryAllocateFlags(pub(crate) Flags); 775 vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); 776 impl MemoryAllocateFlags { 777 #[doc = "Force allocation on specific devices"] 778 pub const DEVICE_MASK: Self = Self(0b1); 779 } 780 #[repr(transparent)] 781 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 782 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html>"] 783 pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); 784 vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); 785 impl DeviceGroupPresentModeFlagsKHR { 786 #[doc = "Present from local memory"] 787 pub const LOCAL: Self = Self(0b1); 788 #[doc = "Present from remote memory"] 789 pub const REMOTE: Self = Self(0b10); 790 #[doc = "Present sum of local and/or remote memory"] 791 pub const SUM: Self = Self(0b100); 792 #[doc = "Each physical device presents from local memory"] 793 pub const LOCAL_MULTI_DEVICE: Self = Self(0b1000); 794 } 795 #[repr(transparent)] 796 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 797 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"] 798 pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); 799 vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); 800 impl SwapchainCreateFlagsKHR {} 801 #[repr(transparent)] 802 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 803 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionFlagBits.html>"] 804 pub struct SubpassDescriptionFlags(pub(crate) Flags); 805 vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); 806 impl SubpassDescriptionFlags {} 807 #[repr(transparent)] 808 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 809 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"] 810 pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); 811 vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1_0001_0001_0001, Flags); 812 impl DebugUtilsMessageSeverityFlagsEXT { 813 pub const VERBOSE: Self = Self(0b1); 814 pub const INFO: Self = Self(0b1_0000); 815 pub const WARNING: Self = Self(0b1_0000_0000); 816 pub const ERROR: Self = Self(0b1_0000_0000_0000); 817 } 818 #[repr(transparent)] 819 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 820 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"] 821 pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); 822 vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); 823 impl DebugUtilsMessageTypeFlagsEXT { 824 pub const GENERAL: Self = Self(0b1); 825 pub const VALIDATION: Self = Self(0b10); 826 pub const PERFORMANCE: Self = Self(0b100); 827 } 828 #[repr(transparent)] 829 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 830 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBindingFlagBits.html>"] 831 pub struct DescriptorBindingFlags(pub(crate) Flags); 832 vk_bitflags_wrapped!(DescriptorBindingFlags, 0b1111, Flags); 833 impl DescriptorBindingFlags { 834 pub const UPDATE_AFTER_BIND: Self = Self(0b1); 835 pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(0b10); 836 pub const PARTIALLY_BOUND: Self = Self(0b100); 837 pub const VARIABLE_DESCRIPTOR_COUNT: Self = Self(0b1000); 838 } 839 #[repr(transparent)] 840 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 841 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"] 842 pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags); 843 vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, 0b1, Flags); 844 impl ConditionalRenderingFlagsEXT { 845 pub const INVERTED: Self = Self(0b1); 846 } 847 #[repr(transparent)] 848 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 849 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveModeFlagBits.html>"] 850 pub struct ResolveModeFlags(pub(crate) Flags); 851 vk_bitflags_wrapped!(ResolveModeFlags, 0b1111, Flags); 852 impl ResolveModeFlags { 853 pub const NONE: Self = Self(0); 854 pub const SAMPLE_ZERO: Self = Self(0b1); 855 pub const AVERAGE: Self = Self(0b10); 856 pub const MIN: Self = Self(0b100); 857 pub const MAX: Self = Self(0b1000); 858 } 859 #[repr(transparent)] 860 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 861 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"] 862 pub struct GeometryInstanceFlagsKHR(pub(crate) Flags); 863 vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, 0b1111, Flags); 864 impl GeometryInstanceFlagsKHR { 865 pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(0b1); 866 pub const TRIANGLE_FLIP_FACING: Self = Self(0b10); 867 pub const FORCE_OPAQUE: Self = Self(0b100); 868 pub const FORCE_NO_OPAQUE: Self = Self(0b1000); 869 pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = Self::TRIANGLE_FLIP_FACING; 870 } 871 #[repr(transparent)] 872 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 873 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryFlagBitsKHR.html>"] 874 pub struct GeometryFlagsKHR(pub(crate) Flags); 875 vk_bitflags_wrapped!(GeometryFlagsKHR, 0b11, Flags); 876 impl GeometryFlagsKHR { 877 pub const OPAQUE: Self = Self(0b1); 878 pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(0b10); 879 } 880 #[repr(transparent)] 881 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 882 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"] 883 pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags); 884 vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, 0b1_1111, Flags); 885 impl BuildAccelerationStructureFlagsKHR { 886 pub const ALLOW_UPDATE: Self = Self(0b1); 887 pub const ALLOW_COMPACTION: Self = Self(0b10); 888 pub const PREFER_FAST_TRACE: Self = Self(0b100); 889 pub const PREFER_FAST_BUILD: Self = Self(0b1000); 890 pub const LOW_MEMORY: Self = Self(0b1_0000); 891 } 892 #[repr(transparent)] 893 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 894 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateFlagBitsKHR.html>"] 895 pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags); 896 vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, 0b1, Flags); 897 impl AccelerationStructureCreateFlagsKHR { 898 pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); 899 } 900 #[repr(transparent)] 901 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 902 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateFlagBits.html>"] 903 pub struct FramebufferCreateFlags(pub(crate) Flags); 904 vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); 905 impl FramebufferCreateFlags {} 906 #[repr(transparent)] 907 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 908 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"] 909 pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags); 910 vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, 0b111, Flags); 911 impl DeviceDiagnosticsConfigFlagsNV { 912 pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1); 913 pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10); 914 pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(0b100); 915 } 916 #[repr(transparent)] 917 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 918 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackFlagBitsEXT.html>"] 919 pub struct PipelineCreationFeedbackFlagsEXT(pub(crate) Flags); 920 vk_bitflags_wrapped!(PipelineCreationFeedbackFlagsEXT, 0b111, Flags); 921 impl PipelineCreationFeedbackFlagsEXT { 922 pub const VALID: Self = Self(0b1); 923 pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10); 924 pub const BASE_PIPELINE_ACCELERATION: Self = Self(0b100); 925 } 926 #[repr(transparent)] 927 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 928 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"] 929 pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags); 930 vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, 0b11, Flags); 931 impl PerformanceCounterDescriptionFlagsKHR { 932 pub const PERFORMANCE_IMPACTING: Self = Self(0b1); 933 pub const CONCURRENTLY_IMPACTED: Self = Self(0b10); 934 } 935 #[repr(transparent)] 936 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 937 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"] 938 pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags); 939 vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, 0b0, Flags); 940 impl AcquireProfilingLockFlagsKHR {} 941 #[repr(transparent)] 942 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 943 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"] 944 pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags); 945 vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, 0b0, Flags); 946 impl ShaderCorePropertiesFlagsAMD {} 947 #[repr(transparent)] 948 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 949 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateFlagBits.html>"] 950 pub struct ShaderModuleCreateFlags(pub(crate) Flags); 951 vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags); 952 impl ShaderModuleCreateFlags {} 953 #[repr(transparent)] 954 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 955 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"] 956 pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags); 957 vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, 0b0, Flags); 958 impl PipelineCompilerControlFlagsAMD {} 959 #[repr(transparent)] 960 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 961 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkToolPurposeFlagBitsEXT.html>"] 962 pub struct ToolPurposeFlagsEXT(pub(crate) Flags); 963 vk_bitflags_wrapped!(ToolPurposeFlagsEXT, 0b1_1111, Flags); 964 impl ToolPurposeFlagsEXT { 965 pub const VALIDATION: Self = Self(0b1); 966 pub const PROFILING: Self = Self(0b10); 967 pub const TRACING: Self = Self(0b100); 968 pub const ADDITIONAL_FEATURES: Self = Self(0b1000); 969 pub const MODIFYING_FEATURES: Self = Self(0b1_0000); 970 } 971 #[repr(transparent)] 972 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 973 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits2KHR.html>"] 974 pub struct AccessFlags2KHR(pub(crate) Flags64); 975 vk_bitflags_wrapped!( 976 AccessFlags2KHR, 977 0b111_0000_0000_0000_0001_1111_1111_1111_1111, 978 Flags64 979 ); 980 impl AccessFlags2KHR { 981 pub const NONE: Self = Self(0); 982 pub const INDIRECT_COMMAND_READ: Self = Self(0b1); 983 pub const INDEX_READ: Self = Self(0b10); 984 pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100); 985 pub const UNIFORM_READ: Self = Self(0b1000); 986 pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000); 987 pub const SHADER_READ: Self = Self(0b10_0000); 988 pub const SHADER_WRITE: Self = Self(0b100_0000); 989 pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000); 990 pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000); 991 pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000); 992 pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000); 993 pub const TRANSFER_READ: Self = Self(0b1000_0000_0000); 994 pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000); 995 pub const HOST_READ: Self = Self(0b10_0000_0000_0000); 996 pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000); 997 pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000); 998 pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000); 999 pub const SHADER_SAMPLED_READ: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); 1000 pub const SHADER_STORAGE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); 1001 pub const SHADER_STORAGE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); 1002 } 1003 #[repr(transparent)] 1004 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1005 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits2KHR.html>"] 1006 pub struct PipelineStageFlags2KHR(pub(crate) Flags64); 1007 vk_bitflags_wrapped!( 1008 PipelineStageFlags2KHR, 1009 0b111_1111_0000_0000_0000_0001_1111_1111_1111_1111, 1010 Flags64 1011 ); 1012 impl PipelineStageFlags2KHR { 1013 pub const NONE: Self = Self(0); 1014 pub const TOP_OF_PIPE: Self = Self(0b1); 1015 pub const DRAW_INDIRECT: Self = Self(0b10); 1016 pub const VERTEX_INPUT: Self = Self(0b100); 1017 pub const VERTEX_SHADER: Self = Self(0b1000); 1018 pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); 1019 pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); 1020 pub const GEOMETRY_SHADER: Self = Self(0b100_0000); 1021 pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); 1022 pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); 1023 pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); 1024 pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); 1025 pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); 1026 pub const ALL_TRANSFER: Self = Self(0b1_0000_0000_0000); 1027 pub const TRANSFER: Self = Self::ALL_TRANSFER; 1028 pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); 1029 pub const HOST: Self = Self(0b100_0000_0000_0000); 1030 pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); 1031 pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); 1032 pub const COPY: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); 1033 pub const RESOLVE: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); 1034 pub const BLIT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); 1035 pub const CLEAR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); 1036 pub const INDEX_INPUT: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1037 pub const VERTEX_ATTRIBUTE_INPUT: Self = 1038 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1039 pub const PRE_RASTERIZATION_SHADERS: Self = 1040 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1041 } 1042 #[repr(transparent)] 1043 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1044 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitFlagBitsKHR.html>"] 1045 pub struct SubmitFlagsKHR(pub(crate) Flags); 1046 vk_bitflags_wrapped!(SubmitFlagsKHR, 0b1, Flags); 1047 impl SubmitFlagsKHR { 1048 pub const PROTECTED: Self = Self(0b1); 1049 } 1050 #[repr(transparent)] 1051 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1052 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateFlagBits.html>"] 1053 pub struct EventCreateFlags(pub(crate) Flags); 1054 vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); 1055 impl EventCreateFlags {} 1056 #[repr(transparent)] 1057 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1058 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateFlagBits.html>"] 1059 pub struct PipelineLayoutCreateFlags(pub(crate) Flags); 1060 vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); 1061 impl PipelineLayoutCreateFlags {} 1062 #[repr(transparent)] 1063 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1064 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"] 1065 pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); 1066 vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, 0b0, Flags); 1067 impl VideoCodecOperationFlagsKHR { 1068 pub const INVALID: Self = Self(0); 1069 } 1070 #[repr(transparent)] 1071 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1072 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html>"] 1073 pub struct VideoChromaSubsamplingFlagsKHR(pub(crate) Flags); 1074 vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, 0b1111, Flags); 1075 impl VideoChromaSubsamplingFlagsKHR { 1076 pub const INVALID: Self = Self(0); 1077 pub const MONOCHROME: Self = Self(0b1); 1078 pub const TYPE_420: Self = Self(0b10); 1079 pub const TYPE_422: Self = Self(0b100); 1080 pub const TYPE_444: Self = Self(0b1000); 1081 } 1082 #[repr(transparent)] 1083 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1084 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoComponentBitDepthFlagBitsKHR.html>"] 1085 pub struct VideoComponentBitDepthFlagsKHR(pub(crate) Flags); 1086 vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, 0b1_0101, Flags); 1087 impl VideoComponentBitDepthFlagsKHR { 1088 pub const INVALID: Self = Self(0); 1089 pub const TYPE_8: Self = Self(0b1); 1090 pub const TYPE_10: Self = Self(0b100); 1091 pub const TYPE_12: Self = Self(0b1_0000); 1092 } 1093 #[repr(transparent)] 1094 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1095 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCapabilityFlagBitsKHR.html>"] 1096 pub struct VideoCapabilityFlagsKHR(pub(crate) Flags); 1097 vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, 0b11, Flags); 1098 impl VideoCapabilityFlagsKHR { 1099 pub const PROTECTED_CONTENT: Self = Self(0b1); 1100 pub const SEPARATE_REFERENCE_IMAGES: Self = Self(0b10); 1101 } 1102 #[repr(transparent)] 1103 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1104 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionCreateFlagBitsKHR.html>"] 1105 pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags); 1106 vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, 0b1, Flags); 1107 impl VideoSessionCreateFlagsKHR { 1108 pub const DEFAULT: Self = Self(0); 1109 pub const PROTECTED_CONTENT: Self = Self(0b1); 1110 } 1111 #[repr(transparent)] 1112 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1113 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingQualityPresetFlagBitsKHR.html>"] 1114 pub struct VideoCodingQualityPresetFlagsKHR(pub(crate) Flags); 1115 vk_bitflags_wrapped!(VideoCodingQualityPresetFlagsKHR, 0b111, Flags); 1116 impl VideoCodingQualityPresetFlagsKHR { 1117 pub const NORMAL: Self = Self(0b1); 1118 pub const POWER: Self = Self(0b10); 1119 pub const QUALITY: Self = Self(0b100); 1120 } 1121 #[repr(transparent)] 1122 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1123 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsEXT.html>"] 1124 pub struct VideoDecodeH264PictureLayoutFlagsEXT(pub(crate) Flags); 1125 vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsEXT, 0b11, Flags); 1126 impl VideoDecodeH264PictureLayoutFlagsEXT { 1127 pub const PROGRESSIVE: Self = Self(0); 1128 pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1); 1129 pub const INTERLACED_SEPARATE_PLANES: Self = Self(0b10); 1130 } 1131 #[repr(transparent)] 1132 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1133 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingControlFlagBitsKHR.html>"] 1134 pub struct VideoCodingControlFlagsKHR(pub(crate) Flags); 1135 vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, 0b1, Flags); 1136 impl VideoCodingControlFlagsKHR { 1137 pub const DEFAULT: Self = Self(0); 1138 pub const RESET: Self = Self(0b1); 1139 } 1140 #[repr(transparent)] 1141 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1142 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeFlagBitsKHR.html>"] 1143 pub struct VideoDecodeFlagsKHR(pub(crate) Flags); 1144 vk_bitflags_wrapped!(VideoDecodeFlagsKHR, 0b1, Flags); 1145 impl VideoDecodeFlagsKHR { 1146 pub const DEFAULT: Self = Self(0); 1147 pub const RESERVED_0: Self = Self(0b1); 1148 } 1149 #[repr(transparent)] 1150 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1151 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeFlagBitsKHR.html>"] 1152 pub struct VideoEncodeFlagsKHR(pub(crate) Flags); 1153 vk_bitflags_wrapped!(VideoEncodeFlagsKHR, 0b1, Flags); 1154 impl VideoEncodeFlagsKHR { 1155 pub const DEFAULT: Self = Self(0); 1156 pub const RESERVED_0: Self = Self(0b1); 1157 } 1158 #[repr(transparent)] 1159 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1160 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlFlagBitsKHR.html>"] 1161 pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags); 1162 vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, 0b1, Flags); 1163 impl VideoEncodeRateControlFlagsKHR { 1164 pub const DEFAULT: Self = Self(0); 1165 pub const RESET: Self = Self(0b1); 1166 } 1167 #[repr(transparent)] 1168 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1169 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html>"] 1170 pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags); 1171 vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, 0b11, Flags); 1172 impl VideoEncodeRateControlModeFlagsKHR { 1173 pub const NONE: Self = Self(0); 1174 pub const CBR: Self = Self(1); 1175 pub const VBR: Self = Self(2); 1176 } 1177 #[repr(transparent)] 1178 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1179 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CapabilityFlagBitsEXT.html>"] 1180 pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags); 1181 vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, 0b111_1111_1111, Flags); 1182 impl VideoEncodeH264CapabilityFlagsEXT { 1183 pub const CABAC: Self = Self(0b1); 1184 pub const CAVLC: Self = Self(0b10); 1185 pub const WEIGHTED_BI_PRED_IMPLICIT: Self = Self(0b100); 1186 pub const TRANSFORM_8X8: Self = Self(0b1000); 1187 pub const CHROMA_QP_OFFSET: Self = Self(0b1_0000); 1188 pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b10_0000); 1189 pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b100_0000); 1190 pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b1000_0000); 1191 pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b1_0000_0000); 1192 pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b10_0000_0000); 1193 pub const EVENLY_DISTRIBUTED_SLICE_SIZE: Self = Self(0b100_0000_0000); 1194 } 1195 #[repr(transparent)] 1196 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1197 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264InputModeFlagBitsEXT.html>"] 1198 pub struct VideoEncodeH264InputModeFlagsEXT(pub(crate) Flags); 1199 vk_bitflags_wrapped!(VideoEncodeH264InputModeFlagsEXT, 0b111, Flags); 1200 impl VideoEncodeH264InputModeFlagsEXT { 1201 pub const FRAME: Self = Self(0b1); 1202 pub const SLICE: Self = Self(0b10); 1203 pub const NON_VCL: Self = Self(0b100); 1204 } 1205 #[repr(transparent)] 1206 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1207 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264OutputModeFlagBitsEXT.html>"] 1208 pub struct VideoEncodeH264OutputModeFlagsEXT(pub(crate) Flags); 1209 vk_bitflags_wrapped!(VideoEncodeH264OutputModeFlagsEXT, 0b111, Flags); 1210 impl VideoEncodeH264OutputModeFlagsEXT { 1211 pub const FRAME: Self = Self(0b1); 1212 pub const SLICE: Self = Self(0b10); 1213 pub const NON_VCL: Self = Self(0b100); 1214 } 1215 #[repr(transparent)] 1216 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1217 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CreateFlagBitsEXT.html>"] 1218 pub struct VideoEncodeH264CreateFlagsEXT(pub(crate) Flags); 1219 vk_bitflags_wrapped!(VideoEncodeH264CreateFlagsEXT, 0b1, Flags); 1220 impl VideoEncodeH264CreateFlagsEXT { 1221 pub const DEFAULT: Self = Self(0); 1222 pub const RESERVED_0: Self = Self(0b1); 1223 } 1224