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 constent 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 constent 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/VkFormatFeatureFlagBits.html>"] 260 pub struct FormatFeatureFlags(pub(crate) Flags); 261 vk_bitflags_wrapped!(FormatFeatureFlags, 0b1_1111_1111_1111, Flags); 262 impl FormatFeatureFlags { 263 #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] 264 pub const SAMPLED_IMAGE: Self = Self(0b1); 265 #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"] 266 pub const STORAGE_IMAGE: Self = Self(0b10); 267 #[doc = "Format supports atomic operations in case it is used for storage images"] 268 pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); 269 #[doc = "Format can be used for uniform texel buffers (TBOs)"] 270 pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); 271 #[doc = "Format can be used for storage texel buffers (IBOs)"] 272 pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); 273 #[doc = "Format supports atomic operations in case it is used for storage texel buffers"] 274 pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); 275 #[doc = "Format can be used for vertex buffers (VBOs)"] 276 pub const VERTEX_BUFFER: Self = Self(0b100_0000); 277 #[doc = "Format can be used for color attachment images"] 278 pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); 279 #[doc = "Format supports blending in case it is used for color attachment images"] 280 pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); 281 #[doc = "Format can be used for depth/stencil attachment images"] 282 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); 283 #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"] 284 pub const BLIT_SRC: Self = Self(0b100_0000_0000); 285 #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"] 286 pub const BLIT_DST: Self = Self(0b1000_0000_0000); 287 #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] 288 pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); 289 } 290 #[repr(transparent)] 291 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 292 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryControlFlagBits.html>"] 293 pub struct QueryControlFlags(pub(crate) Flags); 294 vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); 295 impl QueryControlFlags { 296 #[doc = "Require precise results to be collected by the query"] 297 pub const PRECISE: Self = Self(0b1); 298 } 299 #[repr(transparent)] 300 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 301 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryResultFlagBits.html>"] 302 pub struct QueryResultFlags(pub(crate) Flags); 303 vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); 304 impl QueryResultFlags { 305 #[doc = "Results of the queries are written to the destination buffer as 64-bit values"] 306 pub const TYPE_64: Self = Self(0b1); 307 #[doc = "Results of the queries are waited on before proceeding with the result copy"] 308 pub const WAIT: Self = Self(0b10); 309 #[doc = "Besides the results of the query, the availability of the results is also written"] 310 pub const WITH_AVAILABILITY: Self = Self(0b100); 311 #[doc = "Copy the partial results of the query even if the final results are not available"] 312 pub const PARTIAL: Self = Self(0b1000); 313 } 314 #[repr(transparent)] 315 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 316 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferUsageFlagBits.html>"] 317 pub struct CommandBufferUsageFlags(pub(crate) Flags); 318 vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); 319 impl CommandBufferUsageFlags { 320 pub const ONE_TIME_SUBMIT: Self = Self(0b1); 321 pub const RENDER_PASS_CONTINUE: Self = Self(0b10); 322 #[doc = "Command buffer may be submitted/executed more than once simultaneously"] 323 pub const SIMULTANEOUS_USE: Self = Self(0b100); 324 } 325 #[repr(transparent)] 326 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 327 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"] 328 pub struct QueryPipelineStatisticFlags(pub(crate) Flags); 329 vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b111_1111_1111, Flags); 330 impl QueryPipelineStatisticFlags { 331 #[doc = "Optional"] 332 pub const INPUT_ASSEMBLY_VERTICES: Self = Self(0b1); 333 #[doc = "Optional"] 334 pub const INPUT_ASSEMBLY_PRIMITIVES: Self = Self(0b10); 335 #[doc = "Optional"] 336 pub const VERTEX_SHADER_INVOCATIONS: Self = Self(0b100); 337 #[doc = "Optional"] 338 pub const GEOMETRY_SHADER_INVOCATIONS: Self = Self(0b1000); 339 #[doc = "Optional"] 340 pub const GEOMETRY_SHADER_PRIMITIVES: Self = Self(0b1_0000); 341 #[doc = "Optional"] 342 pub const CLIPPING_INVOCATIONS: Self = Self(0b10_0000); 343 #[doc = "Optional"] 344 pub const CLIPPING_PRIMITIVES: Self = Self(0b100_0000); 345 #[doc = "Optional"] 346 pub const FRAGMENT_SHADER_INVOCATIONS: Self = Self(0b1000_0000); 347 #[doc = "Optional"] 348 pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = Self(0b1_0000_0000); 349 #[doc = "Optional"] 350 pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = Self(0b10_0000_0000); 351 #[doc = "Optional"] 352 pub const COMPUTE_SHADER_INVOCATIONS: Self = Self(0b100_0000_0000); 353 } 354 #[repr(transparent)] 355 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 356 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageAspectFlagBits.html>"] 357 pub struct ImageAspectFlags(pub(crate) Flags); 358 vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); 359 impl ImageAspectFlags { 360 pub const COLOR: Self = Self(0b1); 361 pub const DEPTH: Self = Self(0b10); 362 pub const STENCIL: Self = Self(0b100); 363 pub const METADATA: Self = Self(0b1000); 364 } 365 #[repr(transparent)] 366 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 367 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatFlagBits.html>"] 368 pub struct SparseImageFormatFlags(pub(crate) Flags); 369 vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); 370 impl SparseImageFormatFlags { 371 #[doc = "Image uses a single mip tail region for all array layers"] 372 pub const SINGLE_MIPTAIL: Self = Self(0b1); 373 #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."] 374 pub const ALIGNED_MIP_SIZE: Self = Self(0b10); 375 #[doc = "Image uses a non-standard sparse image block dimensions"] 376 pub const NONSTANDARD_BLOCK_SIZE: Self = Self(0b100); 377 } 378 #[repr(transparent)] 379 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 380 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBindFlagBits.html>"] 381 pub struct SparseMemoryBindFlags(pub(crate) Flags); 382 vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); 383 impl SparseMemoryBindFlags { 384 #[doc = "Operation binds resource metadata to memory"] 385 pub const METADATA: Self = Self(0b1); 386 } 387 #[repr(transparent)] 388 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 389 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits.html>"] 390 pub struct PipelineStageFlags(pub(crate) Flags); 391 vk_bitflags_wrapped!(PipelineStageFlags, 0b1_1111_1111_1111_1111, Flags); 392 impl PipelineStageFlags { 393 #[doc = "Before subsequent commands are processed"] 394 pub const TOP_OF_PIPE: Self = Self(0b1); 395 #[doc = "Draw/DispatchIndirect command fetch"] 396 pub const DRAW_INDIRECT: Self = Self(0b10); 397 #[doc = "Vertex/index fetch"] 398 pub const VERTEX_INPUT: Self = Self(0b100); 399 #[doc = "Vertex shading"] 400 pub const VERTEX_SHADER: Self = Self(0b1000); 401 #[doc = "Tessellation control shading"] 402 pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); 403 #[doc = "Tessellation evaluation shading"] 404 pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); 405 #[doc = "Geometry shading"] 406 pub const GEOMETRY_SHADER: Self = Self(0b100_0000); 407 #[doc = "Fragment shading"] 408 pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); 409 #[doc = "Early fragment (depth and stencil) tests"] 410 pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); 411 #[doc = "Late fragment (depth and stencil) tests"] 412 pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); 413 #[doc = "Color attachment writes"] 414 pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); 415 #[doc = "Compute shading"] 416 pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); 417 #[doc = "Transfer/copy operations"] 418 pub const TRANSFER: Self = Self(0b1_0000_0000_0000); 419 #[doc = "After previous commands have completed"] 420 pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); 421 #[doc = "Indicates host (CPU) is a source/sink of the dependency"] 422 pub const HOST: Self = Self(0b100_0000_0000_0000); 423 #[doc = "All stages of the graphics pipeline"] 424 pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); 425 #[doc = "All stages supported on the queue"] 426 pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); 427 } 428 #[repr(transparent)] 429 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 430 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateFlagBits.html>"] 431 pub struct CommandPoolCreateFlags(pub(crate) Flags); 432 vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); 433 impl CommandPoolCreateFlags { 434 #[doc = "Command buffers have a short lifetime"] 435 pub const TRANSIENT: Self = Self(0b1); 436 #[doc = "Command buffers may release their memory individually"] 437 pub const RESET_COMMAND_BUFFER: Self = Self(0b10); 438 } 439 #[repr(transparent)] 440 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 441 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolResetFlagBits.html>"] 442 pub struct CommandPoolResetFlags(pub(crate) Flags); 443 vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); 444 impl CommandPoolResetFlags { 445 #[doc = "Release resources owned by the pool"] 446 pub const RELEASE_RESOURCES: Self = Self(0b1); 447 } 448 #[repr(transparent)] 449 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 450 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferResetFlagBits.html>"] 451 pub struct CommandBufferResetFlags(pub(crate) Flags); 452 vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); 453 impl CommandBufferResetFlags { 454 #[doc = "Release resources owned by the buffer"] 455 pub const RELEASE_RESOURCES: Self = Self(0b1); 456 } 457 #[repr(transparent)] 458 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 459 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleCountFlagBits.html>"] 460 pub struct SampleCountFlags(pub(crate) Flags); 461 vk_bitflags_wrapped!(SampleCountFlags, 0b111_1111, Flags); 462 impl SampleCountFlags { 463 #[doc = "Sample count 1 supported"] 464 pub const TYPE_1: Self = Self(0b1); 465 #[doc = "Sample count 2 supported"] 466 pub const TYPE_2: Self = Self(0b10); 467 #[doc = "Sample count 4 supported"] 468 pub const TYPE_4: Self = Self(0b100); 469 #[doc = "Sample count 8 supported"] 470 pub const TYPE_8: Self = Self(0b1000); 471 #[doc = "Sample count 16 supported"] 472 pub const TYPE_16: Self = Self(0b1_0000); 473 #[doc = "Sample count 32 supported"] 474 pub const TYPE_32: Self = Self(0b10_0000); 475 #[doc = "Sample count 64 supported"] 476 pub const TYPE_64: Self = Self(0b100_0000); 477 } 478 #[repr(transparent)] 479 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 480 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"] 481 pub struct AttachmentDescriptionFlags(pub(crate) Flags); 482 vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); 483 impl AttachmentDescriptionFlags { 484 #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] 485 pub const MAY_ALIAS: Self = Self(0b1); 486 } 487 #[repr(transparent)] 488 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 489 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilFaceFlagBits.html>"] 490 pub struct StencilFaceFlags(pub(crate) Flags); 491 vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); 492 impl StencilFaceFlags { 493 #[doc = "Front face"] 494 pub const FRONT: Self = Self(0b1); 495 #[doc = "Back face"] 496 pub const BACK: Self = Self(0b10); 497 #[doc = "Front and back faces"] 498 pub const FRONT_AND_BACK: Self = Self(0x0000_0003); 499 } 500 #[repr(transparent)] 501 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 502 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"] 503 pub struct DescriptorPoolCreateFlags(pub(crate) Flags); 504 vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); 505 impl DescriptorPoolCreateFlags { 506 #[doc = "Descriptor sets may be freed individually"] 507 pub const FREE_DESCRIPTOR_SET: Self = Self(0b1); 508 } 509 #[repr(transparent)] 510 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 511 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDependencyFlagBits.html>"] 512 pub struct DependencyFlags(pub(crate) Flags); 513 vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); 514 impl DependencyFlags { 515 #[doc = "Dependency is per pixel region "] 516 pub const BY_REGION: Self = Self(0b1); 517 } 518 #[repr(transparent)] 519 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 520 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitFlagBits.html>"] 521 pub struct SemaphoreWaitFlags(pub(crate) Flags); 522 vk_bitflags_wrapped!(SemaphoreWaitFlags, 0b1, Flags); 523 impl SemaphoreWaitFlags { 524 pub const ANY: 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/VkDisplayPlaneAlphaFlagBitsKHR.html>"] 529 pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); 530 vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); 531 impl DisplayPlaneAlphaFlagsKHR { 532 pub const OPAQUE: Self = Self(0b1); 533 pub const GLOBAL: Self = Self(0b10); 534 pub const PER_PIXEL: Self = Self(0b100); 535 pub const PER_PIXEL_PREMULTIPLIED: Self = Self(0b1000); 536 } 537 #[repr(transparent)] 538 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 539 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"] 540 pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); 541 vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); 542 impl CompositeAlphaFlagsKHR { 543 pub const OPAQUE: Self = Self(0b1); 544 pub const PRE_MULTIPLIED: Self = Self(0b10); 545 pub const POST_MULTIPLIED: Self = Self(0b100); 546 pub const INHERIT: Self = Self(0b1000); 547 } 548 #[repr(transparent)] 549 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 550 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"] 551 pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); 552 vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b1_1111_1111, Flags); 553 impl SurfaceTransformFlagsKHR { 554 pub const IDENTITY: Self = Self(0b1); 555 pub const ROTATE_90: Self = Self(0b10); 556 pub const ROTATE_180: Self = Self(0b100); 557 pub const ROTATE_270: Self = Self(0b1000); 558 pub const HORIZONTAL_MIRROR: Self = Self(0b1_0000); 559 pub const HORIZONTAL_MIRROR_ROTATE_90: Self = Self(0b10_0000); 560 pub const HORIZONTAL_MIRROR_ROTATE_180: Self = Self(0b100_0000); 561 pub const HORIZONTAL_MIRROR_ROTATE_270: Self = Self(0b1000_0000); 562 pub const INHERIT: Self = Self(0b1_0000_0000); 563 } 564 #[repr(transparent)] 565 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 566 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"] 567 pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags); 568 vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, 0b1, Flags); 569 impl SwapchainImageUsageFlagsANDROID { 570 pub const SHARED: Self = Self(0b1); 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/VkDebugReportFlagBitsEXT.html>"] 575 pub struct DebugReportFlagsEXT(pub(crate) Flags); 576 vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b1_1111, Flags); 577 impl DebugReportFlagsEXT { 578 pub const INFORMATION: Self = Self(0b1); 579 pub const WARNING: Self = Self(0b10); 580 pub const PERFORMANCE_WARNING: Self = Self(0b100); 581 pub const ERROR: Self = Self(0b1000); 582 pub const DEBUG: Self = Self(0b1_0000); 583 } 584 #[repr(transparent)] 585 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 586 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"] 587 pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); 588 vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); 589 impl ExternalMemoryHandleTypeFlagsNV { 590 pub const OPAQUE_WIN32: Self = Self(0b1); 591 pub const OPAQUE_WIN32_KMT: Self = Self(0b10); 592 pub const D3D11_IMAGE: Self = Self(0b100); 593 pub const D3D11_IMAGE_KMT: Self = Self(0b1000); 594 } 595 #[repr(transparent)] 596 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 597 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"] 598 pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); 599 vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); 600 impl ExternalMemoryFeatureFlagsNV { 601 pub const DEDICATED_ONLY: Self = Self(0b1); 602 pub const EXPORTABLE: Self = Self(0b10); 603 pub const IMPORTABLE: Self = Self(0b100); 604 } 605 #[repr(transparent)] 606 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 607 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubgroupFeatureFlagBits.html>"] 608 pub struct SubgroupFeatureFlags(pub(crate) Flags); 609 vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b1111_1111, Flags); 610 impl SubgroupFeatureFlags { 611 #[doc = "Basic subgroup operations"] 612 pub const BASIC: Self = Self(0b1); 613 #[doc = "Vote subgroup operations"] 614 pub const VOTE: Self = Self(0b10); 615 #[doc = "Arithmetic subgroup operations"] 616 pub const ARITHMETIC: Self = Self(0b100); 617 #[doc = "Ballot subgroup operations"] 618 pub const BALLOT: Self = Self(0b1000); 619 #[doc = "Shuffle subgroup operations"] 620 pub const SHUFFLE: Self = Self(0b1_0000); 621 #[doc = "Shuffle relative subgroup operations"] 622 pub const SHUFFLE_RELATIVE: Self = Self(0b10_0000); 623 #[doc = "Clustered subgroup operations"] 624 pub const CLUSTERED: Self = Self(0b100_0000); 625 #[doc = "Quad subgroup operations"] 626 pub const QUAD: Self = Self(0b1000_0000); 627 } 628 #[repr(transparent)] 629 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 630 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"] 631 pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags); 632 vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, 0b111, Flags); 633 impl IndirectCommandsLayoutUsageFlagsNV { 634 pub const EXPLICIT_PREPROCESS: Self = Self(0b1); 635 pub const INDEXED_SEQUENCES: Self = Self(0b10); 636 pub const UNORDERED_SEQUENCES: Self = Self(0b100); 637 } 638 #[repr(transparent)] 639 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 640 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagBitsNV.html>"] 641 pub struct IndirectStateFlagsNV(pub(crate) Flags); 642 vk_bitflags_wrapped!(IndirectStateFlagsNV, 0b1, Flags); 643 impl IndirectStateFlagsNV { 644 pub const FLAG_FRONTFACE: Self = Self(0b1); 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/VkPrivateDataSlotCreateFlagBitsEXT.html>"] 649 pub struct PrivateDataSlotCreateFlagsEXT(pub(crate) Flags); 650 vk_bitflags_wrapped!(PrivateDataSlotCreateFlagsEXT, 0b0, Flags); 651 impl PrivateDataSlotCreateFlagsEXT {} 652 #[repr(transparent)] 653 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 654 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"] 655 pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); 656 vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); 657 impl DescriptorSetLayoutCreateFlags {} 658 #[repr(transparent)] 659 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 660 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"] 661 pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); 662 vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b111_1111, Flags); 663 impl ExternalMemoryHandleTypeFlags { 664 pub const OPAQUE_FD: Self = Self(0b1); 665 pub const OPAQUE_WIN32: Self = Self(0b10); 666 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 667 pub const D3D11_TEXTURE: Self = Self(0b1000); 668 pub const D3D11_TEXTURE_KMT: Self = Self(0b1_0000); 669 pub const D3D12_HEAP: Self = Self(0b10_0000); 670 pub const D3D12_RESOURCE: Self = Self(0b100_0000); 671 } 672 #[repr(transparent)] 673 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 674 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"] 675 pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); 676 vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); 677 impl ExternalMemoryFeatureFlags { 678 pub const DEDICATED_ONLY: Self = Self(0b1); 679 pub const EXPORTABLE: Self = Self(0b10); 680 pub const IMPORTABLE: Self = Self(0b100); 681 } 682 #[repr(transparent)] 683 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 684 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"] 685 pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); 686 vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b1_1111, Flags); 687 impl ExternalSemaphoreHandleTypeFlags { 688 pub const OPAQUE_FD: Self = Self(0b1); 689 pub const OPAQUE_WIN32: Self = Self(0b10); 690 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 691 pub const D3D12_FENCE: Self = Self(0b1000); 692 pub const SYNC_FD: Self = Self(0b1_0000); 693 } 694 #[repr(transparent)] 695 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 696 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"] 697 pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); 698 vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); 699 impl ExternalSemaphoreFeatureFlags { 700 pub const EXPORTABLE: Self = Self(0b1); 701 pub const IMPORTABLE: Self = Self(0b10); 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/VkSemaphoreImportFlagBits.html>"] 706 pub struct SemaphoreImportFlags(pub(crate) Flags); 707 vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); 708 impl SemaphoreImportFlags { 709 pub const TEMPORARY: Self = Self(0b1); 710 } 711 #[repr(transparent)] 712 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 713 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"] 714 pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); 715 vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); 716 impl ExternalFenceHandleTypeFlags { 717 pub const OPAQUE_FD: Self = Self(0b1); 718 pub const OPAQUE_WIN32: Self = Self(0b10); 719 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 720 pub const SYNC_FD: Self = Self(0b1000); 721 } 722 #[repr(transparent)] 723 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 724 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"] 725 pub struct ExternalFenceFeatureFlags(pub(crate) Flags); 726 vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); 727 impl ExternalFenceFeatureFlags { 728 pub const EXPORTABLE: Self = Self(0b1); 729 pub const IMPORTABLE: Self = Self(0b10); 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/VkFenceImportFlagBits.html>"] 734 pub struct FenceImportFlags(pub(crate) Flags); 735 vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); 736 impl FenceImportFlags { 737 pub const TEMPORARY: Self = Self(0b1); 738 } 739 #[repr(transparent)] 740 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 741 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"] 742 pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); 743 vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); 744 impl SurfaceCounterFlagsEXT { 745 pub const VBLANK: Self = Self(0b1); 746 } 747 #[repr(transparent)] 748 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 749 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"] 750 pub struct PeerMemoryFeatureFlags(pub(crate) Flags); 751 vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); 752 impl PeerMemoryFeatureFlags { 753 #[doc = "Can read with vkCmdCopy commands"] 754 pub const COPY_SRC: Self = Self(0b1); 755 #[doc = "Can write with vkCmdCopy commands"] 756 pub const COPY_DST: Self = Self(0b10); 757 #[doc = "Can read with any access type/command"] 758 pub const GENERIC_SRC: Self = Self(0b100); 759 #[doc = "Can write with and access type/command"] 760 pub const GENERIC_DST: Self = Self(0b1000); 761 } 762 #[repr(transparent)] 763 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 764 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagBits.html>"] 765 pub struct MemoryAllocateFlags(pub(crate) Flags); 766 vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); 767 impl MemoryAllocateFlags { 768 #[doc = "Force allocation on specific devices"] 769 pub const DEVICE_MASK: Self = Self(0b1); 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/VkDeviceGroupPresentModeFlagBitsKHR.html>"] 774 pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); 775 vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); 776 impl DeviceGroupPresentModeFlagsKHR { 777 #[doc = "Present from local memory"] 778 pub const LOCAL: Self = Self(0b1); 779 #[doc = "Present from remote memory"] 780 pub const REMOTE: Self = Self(0b10); 781 #[doc = "Present sum of local and/or remote memory"] 782 pub const SUM: Self = Self(0b100); 783 #[doc = "Each physical device presents from local memory"] 784 pub const LOCAL_MULTI_DEVICE: Self = Self(0b1000); 785 } 786 #[repr(transparent)] 787 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 788 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"] 789 pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); 790 vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); 791 impl SwapchainCreateFlagsKHR {} 792 #[repr(transparent)] 793 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 794 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionFlagBits.html>"] 795 pub struct SubpassDescriptionFlags(pub(crate) Flags); 796 vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); 797 impl SubpassDescriptionFlags {} 798 #[repr(transparent)] 799 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 800 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"] 801 pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); 802 vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1_0001_0001_0001, Flags); 803 impl DebugUtilsMessageSeverityFlagsEXT { 804 pub const VERBOSE: Self = Self(0b1); 805 pub const INFO: Self = Self(0b1_0000); 806 pub const WARNING: Self = Self(0b1_0000_0000); 807 pub const ERROR: Self = Self(0b1_0000_0000_0000); 808 } 809 #[repr(transparent)] 810 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 811 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"] 812 pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); 813 vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); 814 impl DebugUtilsMessageTypeFlagsEXT { 815 pub const GENERAL: Self = Self(0b1); 816 pub const VALIDATION: Self = Self(0b10); 817 pub const PERFORMANCE: Self = Self(0b100); 818 } 819 #[repr(transparent)] 820 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 821 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBindingFlagBits.html>"] 822 pub struct DescriptorBindingFlags(pub(crate) Flags); 823 vk_bitflags_wrapped!(DescriptorBindingFlags, 0b1111, Flags); 824 impl DescriptorBindingFlags { 825 pub const UPDATE_AFTER_BIND: Self = Self(0b1); 826 pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(0b10); 827 pub const PARTIALLY_BOUND: Self = Self(0b100); 828 pub const VARIABLE_DESCRIPTOR_COUNT: Self = Self(0b1000); 829 } 830 #[repr(transparent)] 831 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 832 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"] 833 pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags); 834 vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, 0b1, Flags); 835 impl ConditionalRenderingFlagsEXT { 836 pub const INVERTED: Self = Self(0b1); 837 } 838 #[repr(transparent)] 839 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 840 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveModeFlagBits.html>"] 841 pub struct ResolveModeFlags(pub(crate) Flags); 842 vk_bitflags_wrapped!(ResolveModeFlags, 0b1111, Flags); 843 impl ResolveModeFlags { 844 pub const NONE: Self = Self(0); 845 pub const SAMPLE_ZERO: Self = Self(0b1); 846 pub const AVERAGE: Self = Self(0b10); 847 pub const MIN: Self = Self(0b100); 848 pub const MAX: Self = Self(0b1000); 849 } 850 #[repr(transparent)] 851 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 852 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"] 853 pub struct GeometryInstanceFlagsKHR(pub(crate) Flags); 854 vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, 0b1111, Flags); 855 impl GeometryInstanceFlagsKHR { 856 pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(0b1); 857 pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = Self(0b10); 858 pub const FORCE_OPAQUE: Self = Self(0b100); 859 pub const FORCE_NO_OPAQUE: Self = Self(0b1000); 860 } 861 #[repr(transparent)] 862 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 863 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryFlagBitsKHR.html>"] 864 pub struct GeometryFlagsKHR(pub(crate) Flags); 865 vk_bitflags_wrapped!(GeometryFlagsKHR, 0b11, Flags); 866 impl GeometryFlagsKHR { 867 pub const OPAQUE: Self = Self(0b1); 868 pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(0b10); 869 } 870 #[repr(transparent)] 871 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 872 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"] 873 pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags); 874 vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, 0b1_1111, Flags); 875 impl BuildAccelerationStructureFlagsKHR { 876 pub const ALLOW_UPDATE: Self = Self(0b1); 877 pub const ALLOW_COMPACTION: Self = Self(0b10); 878 pub const PREFER_FAST_TRACE: Self = Self(0b100); 879 pub const PREFER_FAST_BUILD: Self = Self(0b1000); 880 pub const LOW_MEMORY: Self = Self(0b1_0000); 881 } 882 #[repr(transparent)] 883 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 884 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateFlagBitsKHR.html>"] 885 pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags); 886 vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, 0b1, Flags); 887 impl AccelerationStructureCreateFlagsKHR { 888 pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); 889 } 890 #[repr(transparent)] 891 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 892 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateFlagBits.html>"] 893 pub struct FramebufferCreateFlags(pub(crate) Flags); 894 vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); 895 impl FramebufferCreateFlags {} 896 #[repr(transparent)] 897 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 898 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"] 899 pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags); 900 vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, 0b111, Flags); 901 impl DeviceDiagnosticsConfigFlagsNV { 902 pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1); 903 pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10); 904 pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(0b100); 905 } 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/VkPipelineCreationFeedbackFlagBitsEXT.html>"] 909 pub struct PipelineCreationFeedbackFlagsEXT(pub(crate) Flags); 910 vk_bitflags_wrapped!(PipelineCreationFeedbackFlagsEXT, 0b111, Flags); 911 impl PipelineCreationFeedbackFlagsEXT { 912 pub const VALID: Self = Self(0b1); 913 pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10); 914 pub const BASE_PIPELINE_ACCELERATION: 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/VkPerformanceCounterDescriptionFlagBitsKHR.html>"] 919 pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags); 920 vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, 0b11, Flags); 921 impl PerformanceCounterDescriptionFlagsKHR { 922 pub const PERFORMANCE_IMPACTING: Self = Self(0b1); 923 pub const CONCURRENTLY_IMPACTED: Self = Self(0b10); 924 } 925 #[repr(transparent)] 926 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 927 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"] 928 pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags); 929 vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, 0b0, Flags); 930 impl AcquireProfilingLockFlagsKHR {} 931 #[repr(transparent)] 932 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 933 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"] 934 pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags); 935 vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, 0b0, Flags); 936 impl ShaderCorePropertiesFlagsAMD {} 937 #[repr(transparent)] 938 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 939 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateFlagBits.html>"] 940 pub struct ShaderModuleCreateFlags(pub(crate) Flags); 941 vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags); 942 impl ShaderModuleCreateFlags {} 943 #[repr(transparent)] 944 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 945 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"] 946 pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags); 947 vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, 0b0, Flags); 948 impl PipelineCompilerControlFlagsAMD {} 949 #[repr(transparent)] 950 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 951 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkToolPurposeFlagBitsEXT.html>"] 952 pub struct ToolPurposeFlagsEXT(pub(crate) Flags); 953 vk_bitflags_wrapped!(ToolPurposeFlagsEXT, 0b1_1111, Flags); 954 impl ToolPurposeFlagsEXT { 955 pub const VALIDATION: Self = Self(0b1); 956 pub const PROFILING: Self = Self(0b10); 957 pub const TRACING: Self = Self(0b100); 958 pub const ADDITIONAL_FEATURES: Self = Self(0b1000); 959 pub const MODIFYING_FEATURES: Self = Self(0b1_0000); 960 } 961