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.3-extensions/man/html/VkPipelineCacheCreateFlagBits.html>"] 5 pub struct PipelineCacheCreateFlags(pub(crate) Flags); 6 vk_bitflags_wrapped!(PipelineCacheCreateFlags, 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.3-extensions/man/html/VkQueueFlagBits.html>"] 11 pub struct QueueFlags(pub(crate) Flags); 12 vk_bitflags_wrapped!(QueueFlags, 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.3-extensions/man/html/VkCullModeFlagBits.html>"] 26 pub struct CullModeFlags(pub(crate) Flags); 27 vk_bitflags_wrapped!(CullModeFlags, 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.3-extensions/man/html/VkRenderPassCreateFlagBits.html>"] 37 pub struct RenderPassCreateFlags(pub(crate) Flags); 38 vk_bitflags_wrapped!(RenderPassCreateFlags, 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.3-extensions/man/html/VkDeviceQueueCreateFlagBits.html>"] 43 pub struct DeviceQueueCreateFlags(pub(crate) Flags); 44 vk_bitflags_wrapped!(DeviceQueueCreateFlags, 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.3-extensions/man/html/VkMemoryPropertyFlagBits.html>"] 49 pub struct MemoryPropertyFlags(pub(crate) Flags); 50 vk_bitflags_wrapped!(MemoryPropertyFlags, 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.3-extensions/man/html/VkMemoryHeapFlagBits.html>"] 66 pub struct MemoryHeapFlags(pub(crate) Flags); 67 vk_bitflags_wrapped!(MemoryHeapFlags, 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.3-extensions/man/html/VkAccessFlagBits.html>"] 75 pub struct AccessFlags(pub(crate) Flags); 76 vk_bitflags_wrapped!(AccessFlags, 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.3-extensions/man/html/VkBufferUsageFlagBits.html>"] 116 pub struct BufferUsageFlags(pub(crate) Flags); 117 vk_bitflags_wrapped!(BufferUsageFlags, 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.3-extensions/man/html/VkBufferCreateFlagBits.html>"] 141 pub struct BufferCreateFlags(pub(crate) Flags); 142 vk_bitflags_wrapped!(BufferCreateFlags, 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.3-extensions/man/html/VkShaderStageFlagBits.html>"] 154 pub struct ShaderStageFlags(pub(crate) Flags); 155 vk_bitflags_wrapped!(ShaderStageFlags, Flags); 156 impl ShaderStageFlags { 157 pub const VERTEX: Self = Self(0b1); 158 pub const TESSELLATION_CONTROL: Self = Self(0b10); 159 pub const TESSELLATION_EVALUATION: Self = Self(0b100); 160 pub const GEOMETRY: Self = Self(0b1000); 161 pub const FRAGMENT: Self = Self(0b1_0000); 162 pub const COMPUTE: Self = Self(0b10_0000); 163 pub const ALL_GRAPHICS: Self = Self(0x0000_001F); 164 pub const ALL: Self = Self(0x7FFF_FFFF); 165 } 166 #[repr(transparent)] 167 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 168 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageUsageFlagBits.html>"] 169 pub struct ImageUsageFlags(pub(crate) Flags); 170 vk_bitflags_wrapped!(ImageUsageFlags, Flags); 171 impl ImageUsageFlags { 172 #[doc = "Can be used as a source of transfer operations"] 173 pub const TRANSFER_SRC: Self = Self(0b1); 174 #[doc = "Can be used as a destination of transfer operations"] 175 pub const TRANSFER_DST: Self = Self(0b10); 176 #[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] 177 pub const SAMPLED: Self = Self(0b100); 178 #[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"] 179 pub const STORAGE: Self = Self(0b1000); 180 #[doc = "Can be used as framebuffer color attachment"] 181 pub const COLOR_ATTACHMENT: Self = Self(0b1_0000); 182 #[doc = "Can be used as framebuffer depth/stencil attachment"] 183 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000); 184 #[doc = "Image data not needed outside of rendering"] 185 pub const TRANSIENT_ATTACHMENT: Self = Self(0b100_0000); 186 #[doc = "Can be used as framebuffer input attachment"] 187 pub const INPUT_ATTACHMENT: Self = Self(0b1000_0000); 188 } 189 #[repr(transparent)] 190 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 191 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateFlagBits.html>"] 192 pub struct ImageCreateFlags(pub(crate) Flags); 193 vk_bitflags_wrapped!(ImageCreateFlags, Flags); 194 impl ImageCreateFlags { 195 #[doc = "Image should support sparse backing"] 196 pub const SPARSE_BINDING: Self = Self(0b1); 197 #[doc = "Image should support sparse backing with partial residency"] 198 pub const SPARSE_RESIDENCY: Self = Self(0b10); 199 #[doc = "Image should support constant data access to physical memory ranges mapped into multiple locations of sparse images"] 200 pub const SPARSE_ALIASED: Self = Self(0b100); 201 #[doc = "Allows image views to have different format than the base image"] 202 pub const MUTABLE_FORMAT: Self = Self(0b1000); 203 #[doc = "Allows creating image views with cube type from the created image"] 204 pub const CUBE_COMPATIBLE: Self = Self(0b1_0000); 205 } 206 #[repr(transparent)] 207 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 208 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateFlagBits.html>"] 209 pub struct ImageViewCreateFlags(pub(crate) Flags); 210 vk_bitflags_wrapped!(ImageViewCreateFlags, Flags); 211 impl ImageViewCreateFlags {} 212 #[repr(transparent)] 213 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 214 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateFlagBits.html>"] 215 pub struct SamplerCreateFlags(pub(crate) Flags); 216 vk_bitflags_wrapped!(SamplerCreateFlags, Flags); 217 impl SamplerCreateFlags {} 218 #[repr(transparent)] 219 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 220 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreateFlagBits.html>"] 221 pub struct PipelineCreateFlags(pub(crate) Flags); 222 vk_bitflags_wrapped!(PipelineCreateFlags, Flags); 223 impl PipelineCreateFlags { 224 pub const DISABLE_OPTIMIZATION: Self = Self(0b1); 225 pub const ALLOW_DERIVATIVES: Self = Self(0b10); 226 pub const DERIVATIVE: Self = Self(0b100); 227 } 228 #[repr(transparent)] 229 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 230 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateFlagBits.html>"] 231 pub struct PipelineShaderStageCreateFlags(pub(crate) Flags); 232 vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, Flags); 233 impl PipelineShaderStageCreateFlags {} 234 #[repr(transparent)] 235 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 236 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorComponentFlagBits.html>"] 237 pub struct ColorComponentFlags(pub(crate) Flags); 238 vk_bitflags_wrapped!(ColorComponentFlags, Flags); 239 impl ColorComponentFlags { 240 pub const R: Self = Self(0b1); 241 pub const G: Self = Self(0b10); 242 pub const B: Self = Self(0b100); 243 pub const A: Self = Self(0b1000); 244 } 245 #[repr(transparent)] 246 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 247 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateFlagBits.html>"] 248 pub struct FenceCreateFlags(pub(crate) Flags); 249 vk_bitflags_wrapped!(FenceCreateFlags, Flags); 250 impl FenceCreateFlags { 251 pub const SIGNALED: Self = Self(0b1); 252 } 253 #[repr(transparent)] 254 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 255 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateFlagBits.html>"] 256 pub struct SemaphoreCreateFlags(pub(crate) Flags); 257 vk_bitflags_wrapped!(SemaphoreCreateFlags, Flags); 258 impl SemaphoreCreateFlags {} 259 #[repr(transparent)] 260 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 261 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatFeatureFlagBits.html>"] 262 pub struct FormatFeatureFlags(pub(crate) Flags); 263 vk_bitflags_wrapped!(FormatFeatureFlags, Flags); 264 impl FormatFeatureFlags { 265 #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] 266 pub const SAMPLED_IMAGE: Self = Self(0b1); 267 #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"] 268 pub const STORAGE_IMAGE: Self = Self(0b10); 269 #[doc = "Format supports atomic operations in case it is used for storage images"] 270 pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); 271 #[doc = "Format can be used for uniform texel buffers (TBOs)"] 272 pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); 273 #[doc = "Format can be used for storage texel buffers (IBOs)"] 274 pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); 275 #[doc = "Format supports atomic operations in case it is used for storage texel buffers"] 276 pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); 277 #[doc = "Format can be used for vertex buffers (VBOs)"] 278 pub const VERTEX_BUFFER: Self = Self(0b100_0000); 279 #[doc = "Format can be used for color attachment images"] 280 pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); 281 #[doc = "Format supports blending in case it is used for color attachment images"] 282 pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); 283 #[doc = "Format can be used for depth/stencil attachment images"] 284 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); 285 #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"] 286 pub const BLIT_SRC: Self = Self(0b100_0000_0000); 287 #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"] 288 pub const BLIT_DST: Self = Self(0b1000_0000_0000); 289 #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] 290 pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); 291 } 292 #[repr(transparent)] 293 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 294 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryControlFlagBits.html>"] 295 pub struct QueryControlFlags(pub(crate) Flags); 296 vk_bitflags_wrapped!(QueryControlFlags, Flags); 297 impl QueryControlFlags { 298 #[doc = "Require precise results to be collected by the query"] 299 pub const PRECISE: Self = Self(0b1); 300 } 301 #[repr(transparent)] 302 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 303 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryResultFlagBits.html>"] 304 pub struct QueryResultFlags(pub(crate) Flags); 305 vk_bitflags_wrapped!(QueryResultFlags, Flags); 306 impl QueryResultFlags { 307 #[doc = "Results of the queries are written to the destination buffer as 64-bit values"] 308 pub const TYPE_64: Self = Self(0b1); 309 #[doc = "Results of the queries are waited on before proceeding with the result copy"] 310 pub const WAIT: Self = Self(0b10); 311 #[doc = "Besides the results of the query, the availability of the results is also written"] 312 pub const WITH_AVAILABILITY: Self = Self(0b100); 313 #[doc = "Copy the partial results of the query even if the final results are not available"] 314 pub const PARTIAL: Self = Self(0b1000); 315 } 316 #[repr(transparent)] 317 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 318 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferUsageFlagBits.html>"] 319 pub struct CommandBufferUsageFlags(pub(crate) Flags); 320 vk_bitflags_wrapped!(CommandBufferUsageFlags, Flags); 321 impl CommandBufferUsageFlags { 322 pub const ONE_TIME_SUBMIT: Self = Self(0b1); 323 pub const RENDER_PASS_CONTINUE: Self = Self(0b10); 324 #[doc = "Command buffer may be submitted/executed more than once simultaneously"] 325 pub const SIMULTANEOUS_USE: Self = Self(0b100); 326 } 327 #[repr(transparent)] 328 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 329 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"] 330 pub struct QueryPipelineStatisticFlags(pub(crate) Flags); 331 vk_bitflags_wrapped!(QueryPipelineStatisticFlags, Flags); 332 impl QueryPipelineStatisticFlags { 333 #[doc = "Optional"] 334 pub const INPUT_ASSEMBLY_VERTICES: Self = Self(0b1); 335 #[doc = "Optional"] 336 pub const INPUT_ASSEMBLY_PRIMITIVES: Self = Self(0b10); 337 #[doc = "Optional"] 338 pub const VERTEX_SHADER_INVOCATIONS: Self = Self(0b100); 339 #[doc = "Optional"] 340 pub const GEOMETRY_SHADER_INVOCATIONS: Self = Self(0b1000); 341 #[doc = "Optional"] 342 pub const GEOMETRY_SHADER_PRIMITIVES: Self = Self(0b1_0000); 343 #[doc = "Optional"] 344 pub const CLIPPING_INVOCATIONS: Self = Self(0b10_0000); 345 #[doc = "Optional"] 346 pub const CLIPPING_PRIMITIVES: Self = Self(0b100_0000); 347 #[doc = "Optional"] 348 pub const FRAGMENT_SHADER_INVOCATIONS: Self = Self(0b1000_0000); 349 #[doc = "Optional"] 350 pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = Self(0b1_0000_0000); 351 #[doc = "Optional"] 352 pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = Self(0b10_0000_0000); 353 #[doc = "Optional"] 354 pub const COMPUTE_SHADER_INVOCATIONS: Self = Self(0b100_0000_0000); 355 } 356 #[repr(transparent)] 357 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 358 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageAspectFlagBits.html>"] 359 pub struct ImageAspectFlags(pub(crate) Flags); 360 vk_bitflags_wrapped!(ImageAspectFlags, Flags); 361 impl ImageAspectFlags { 362 pub const COLOR: Self = Self(0b1); 363 pub const DEPTH: Self = Self(0b10); 364 pub const STENCIL: Self = Self(0b100); 365 pub const METADATA: Self = Self(0b1000); 366 } 367 #[repr(transparent)] 368 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 369 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatFlagBits.html>"] 370 pub struct SparseImageFormatFlags(pub(crate) Flags); 371 vk_bitflags_wrapped!(SparseImageFormatFlags, Flags); 372 impl SparseImageFormatFlags { 373 #[doc = "Image uses a single mip tail region for all array layers"] 374 pub const SINGLE_MIPTAIL: Self = Self(0b1); 375 #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."] 376 pub const ALIGNED_MIP_SIZE: Self = Self(0b10); 377 #[doc = "Image uses a non-standard sparse image block dimensions"] 378 pub const NONSTANDARD_BLOCK_SIZE: Self = Self(0b100); 379 } 380 #[repr(transparent)] 381 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 382 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBindFlagBits.html>"] 383 pub struct SparseMemoryBindFlags(pub(crate) Flags); 384 vk_bitflags_wrapped!(SparseMemoryBindFlags, Flags); 385 impl SparseMemoryBindFlags { 386 #[doc = "Operation binds resource metadata to memory"] 387 pub const METADATA: Self = Self(0b1); 388 } 389 #[repr(transparent)] 390 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 391 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineStageFlagBits.html>"] 392 pub struct PipelineStageFlags(pub(crate) Flags); 393 vk_bitflags_wrapped!(PipelineStageFlags, Flags); 394 impl PipelineStageFlags { 395 #[doc = "Before subsequent commands are processed"] 396 pub const TOP_OF_PIPE: Self = Self(0b1); 397 #[doc = "Draw/DispatchIndirect command fetch"] 398 pub const DRAW_INDIRECT: Self = Self(0b10); 399 #[doc = "Vertex/index fetch"] 400 pub const VERTEX_INPUT: Self = Self(0b100); 401 #[doc = "Vertex shading"] 402 pub const VERTEX_SHADER: Self = Self(0b1000); 403 #[doc = "Tessellation control shading"] 404 pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); 405 #[doc = "Tessellation evaluation shading"] 406 pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); 407 #[doc = "Geometry shading"] 408 pub const GEOMETRY_SHADER: Self = Self(0b100_0000); 409 #[doc = "Fragment shading"] 410 pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); 411 #[doc = "Early fragment (depth and stencil) tests"] 412 pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); 413 #[doc = "Late fragment (depth and stencil) tests"] 414 pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); 415 #[doc = "Color attachment writes"] 416 pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); 417 #[doc = "Compute shading"] 418 pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); 419 #[doc = "Transfer/copy operations"] 420 pub const TRANSFER: Self = Self(0b1_0000_0000_0000); 421 #[doc = "After previous commands have completed"] 422 pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); 423 #[doc = "Indicates host (CPU) is a source/sink of the dependency"] 424 pub const HOST: Self = Self(0b100_0000_0000_0000); 425 #[doc = "All stages of the graphics pipeline"] 426 pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); 427 #[doc = "All stages supported on the queue"] 428 pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); 429 } 430 #[repr(transparent)] 431 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 432 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateFlagBits.html>"] 433 pub struct CommandPoolCreateFlags(pub(crate) Flags); 434 vk_bitflags_wrapped!(CommandPoolCreateFlags, Flags); 435 impl CommandPoolCreateFlags { 436 #[doc = "Command buffers have a short lifetime"] 437 pub const TRANSIENT: Self = Self(0b1); 438 #[doc = "Command buffers may release their memory individually"] 439 pub const RESET_COMMAND_BUFFER: Self = Self(0b10); 440 } 441 #[repr(transparent)] 442 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 443 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolResetFlagBits.html>"] 444 pub struct CommandPoolResetFlags(pub(crate) Flags); 445 vk_bitflags_wrapped!(CommandPoolResetFlags, Flags); 446 impl CommandPoolResetFlags { 447 #[doc = "Release resources owned by the pool"] 448 pub const RELEASE_RESOURCES: Self = Self(0b1); 449 } 450 #[repr(transparent)] 451 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 452 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferResetFlagBits.html>"] 453 pub struct CommandBufferResetFlags(pub(crate) Flags); 454 vk_bitflags_wrapped!(CommandBufferResetFlags, Flags); 455 impl CommandBufferResetFlags { 456 #[doc = "Release resources owned by the buffer"] 457 pub const RELEASE_RESOURCES: Self = Self(0b1); 458 } 459 #[repr(transparent)] 460 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 461 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleCountFlagBits.html>"] 462 pub struct SampleCountFlags(pub(crate) Flags); 463 vk_bitflags_wrapped!(SampleCountFlags, Flags); 464 impl SampleCountFlags { 465 #[doc = "Sample count 1 supported"] 466 pub const TYPE_1: Self = Self(0b1); 467 #[doc = "Sample count 2 supported"] 468 pub const TYPE_2: Self = Self(0b10); 469 #[doc = "Sample count 4 supported"] 470 pub const TYPE_4: Self = Self(0b100); 471 #[doc = "Sample count 8 supported"] 472 pub const TYPE_8: Self = Self(0b1000); 473 #[doc = "Sample count 16 supported"] 474 pub const TYPE_16: Self = Self(0b1_0000); 475 #[doc = "Sample count 32 supported"] 476 pub const TYPE_32: Self = Self(0b10_0000); 477 #[doc = "Sample count 64 supported"] 478 pub const TYPE_64: Self = Self(0b100_0000); 479 } 480 #[repr(transparent)] 481 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 482 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"] 483 pub struct AttachmentDescriptionFlags(pub(crate) Flags); 484 vk_bitflags_wrapped!(AttachmentDescriptionFlags, Flags); 485 impl AttachmentDescriptionFlags { 486 #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] 487 pub const MAY_ALIAS: Self = Self(0b1); 488 } 489 #[repr(transparent)] 490 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 491 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilFaceFlagBits.html>"] 492 pub struct StencilFaceFlags(pub(crate) Flags); 493 vk_bitflags_wrapped!(StencilFaceFlags, Flags); 494 impl StencilFaceFlags { 495 #[doc = "Front face"] 496 pub const FRONT: Self = Self(0b1); 497 #[doc = "Back face"] 498 pub const BACK: Self = Self(0b10); 499 #[doc = "Front and back faces"] 500 pub const FRONT_AND_BACK: Self = Self(0x0000_0003); 501 } 502 #[repr(transparent)] 503 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 504 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"] 505 pub struct DescriptorPoolCreateFlags(pub(crate) Flags); 506 vk_bitflags_wrapped!(DescriptorPoolCreateFlags, Flags); 507 impl DescriptorPoolCreateFlags { 508 #[doc = "Descriptor sets may be freed individually"] 509 pub const FREE_DESCRIPTOR_SET: Self = Self(0b1); 510 } 511 #[repr(transparent)] 512 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 513 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyFlagBits.html>"] 514 pub struct DependencyFlags(pub(crate) Flags); 515 vk_bitflags_wrapped!(DependencyFlags, Flags); 516 impl DependencyFlags { 517 #[doc = "Dependency is per pixel region "] 518 pub const BY_REGION: Self = Self(0b1); 519 } 520 #[repr(transparent)] 521 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 522 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitFlagBits.html>"] 523 pub struct SemaphoreWaitFlags(pub(crate) Flags); 524 vk_bitflags_wrapped!(SemaphoreWaitFlags, Flags); 525 impl SemaphoreWaitFlags { 526 pub const ANY: Self = Self(0b1); 527 } 528 #[repr(transparent)] 529 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 530 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html>"] 531 pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); 532 vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, Flags); 533 impl DisplayPlaneAlphaFlagsKHR { 534 pub const OPAQUE: Self = Self(0b1); 535 pub const GLOBAL: Self = Self(0b10); 536 pub const PER_PIXEL: Self = Self(0b100); 537 pub const PER_PIXEL_PREMULTIPLIED: Self = Self(0b1000); 538 } 539 #[repr(transparent)] 540 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 541 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"] 542 pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); 543 vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, Flags); 544 impl CompositeAlphaFlagsKHR { 545 pub const OPAQUE: Self = Self(0b1); 546 pub const PRE_MULTIPLIED: Self = Self(0b10); 547 pub const POST_MULTIPLIED: Self = Self(0b100); 548 pub const INHERIT: Self = Self(0b1000); 549 } 550 #[repr(transparent)] 551 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 552 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"] 553 pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); 554 vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, Flags); 555 impl SurfaceTransformFlagsKHR { 556 pub const IDENTITY: Self = Self(0b1); 557 pub const ROTATE_90: Self = Self(0b10); 558 pub const ROTATE_180: Self = Self(0b100); 559 pub const ROTATE_270: Self = Self(0b1000); 560 pub const HORIZONTAL_MIRROR: Self = Self(0b1_0000); 561 pub const HORIZONTAL_MIRROR_ROTATE_90: Self = Self(0b10_0000); 562 pub const HORIZONTAL_MIRROR_ROTATE_180: Self = Self(0b100_0000); 563 pub const HORIZONTAL_MIRROR_ROTATE_270: Self = Self(0b1000_0000); 564 pub const INHERIT: Self = Self(0b1_0000_0000); 565 } 566 #[repr(transparent)] 567 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 568 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"] 569 pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags); 570 vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, Flags); 571 impl SwapchainImageUsageFlagsANDROID { 572 pub const SHARED: Self = Self(0b1); 573 } 574 #[repr(transparent)] 575 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 576 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportFlagBitsEXT.html>"] 577 pub struct DebugReportFlagsEXT(pub(crate) Flags); 578 vk_bitflags_wrapped!(DebugReportFlagsEXT, Flags); 579 impl DebugReportFlagsEXT { 580 pub const INFORMATION: Self = Self(0b1); 581 pub const WARNING: Self = Self(0b10); 582 pub const PERFORMANCE_WARNING: Self = Self(0b100); 583 pub const ERROR: Self = Self(0b1000); 584 pub const DEBUG: Self = Self(0b1_0000); 585 } 586 #[repr(transparent)] 587 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 588 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"] 589 pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); 590 vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, Flags); 591 impl ExternalMemoryHandleTypeFlagsNV { 592 pub const OPAQUE_WIN32: Self = Self(0b1); 593 pub const OPAQUE_WIN32_KMT: Self = Self(0b10); 594 pub const D3D11_IMAGE: Self = Self(0b100); 595 pub const D3D11_IMAGE_KMT: Self = Self(0b1000); 596 } 597 #[repr(transparent)] 598 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 599 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"] 600 pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); 601 vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, Flags); 602 impl ExternalMemoryFeatureFlagsNV { 603 pub const DEDICATED_ONLY: Self = Self(0b1); 604 pub const EXPORTABLE: Self = Self(0b10); 605 pub const IMPORTABLE: Self = Self(0b100); 606 } 607 #[repr(transparent)] 608 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 609 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubgroupFeatureFlagBits.html>"] 610 pub struct SubgroupFeatureFlags(pub(crate) Flags); 611 vk_bitflags_wrapped!(SubgroupFeatureFlags, Flags); 612 impl SubgroupFeatureFlags { 613 #[doc = "Basic subgroup operations"] 614 pub const BASIC: Self = Self(0b1); 615 #[doc = "Vote subgroup operations"] 616 pub const VOTE: Self = Self(0b10); 617 #[doc = "Arithmetic subgroup operations"] 618 pub const ARITHMETIC: Self = Self(0b100); 619 #[doc = "Ballot subgroup operations"] 620 pub const BALLOT: Self = Self(0b1000); 621 #[doc = "Shuffle subgroup operations"] 622 pub const SHUFFLE: Self = Self(0b1_0000); 623 #[doc = "Shuffle relative subgroup operations"] 624 pub const SHUFFLE_RELATIVE: Self = Self(0b10_0000); 625 #[doc = "Clustered subgroup operations"] 626 pub const CLUSTERED: Self = Self(0b100_0000); 627 #[doc = "Quad subgroup operations"] 628 pub const QUAD: Self = Self(0b1000_0000); 629 } 630 #[repr(transparent)] 631 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 632 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"] 633 pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags); 634 vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, Flags); 635 impl IndirectCommandsLayoutUsageFlagsNV { 636 pub const EXPLICIT_PREPROCESS: Self = Self(0b1); 637 pub const INDEXED_SEQUENCES: Self = Self(0b10); 638 pub const UNORDERED_SEQUENCES: Self = Self(0b100); 639 } 640 #[repr(transparent)] 641 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 642 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectStateFlagBitsNV.html>"] 643 pub struct IndirectStateFlagsNV(pub(crate) Flags); 644 vk_bitflags_wrapped!(IndirectStateFlagsNV, Flags); 645 impl IndirectStateFlagsNV { 646 pub const FLAG_FRONTFACE: Self = Self(0b1); 647 } 648 #[repr(transparent)] 649 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 650 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateFlagBits.html>"] 651 pub struct PrivateDataSlotCreateFlags(pub(crate) Flags); 652 vk_bitflags_wrapped!(PrivateDataSlotCreateFlags, Flags); 653 impl PrivateDataSlotCreateFlags {} 654 #[repr(transparent)] 655 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 656 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"] 657 pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); 658 vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, Flags); 659 impl DescriptorSetLayoutCreateFlags {} 660 #[repr(transparent)] 661 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 662 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"] 663 pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); 664 vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, Flags); 665 impl ExternalMemoryHandleTypeFlags { 666 pub const OPAQUE_FD: Self = Self(0b1); 667 pub const OPAQUE_WIN32: Self = Self(0b10); 668 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 669 pub const D3D11_TEXTURE: Self = Self(0b1000); 670 pub const D3D11_TEXTURE_KMT: Self = Self(0b1_0000); 671 pub const D3D12_HEAP: Self = Self(0b10_0000); 672 pub const D3D12_RESOURCE: Self = Self(0b100_0000); 673 } 674 #[repr(transparent)] 675 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 676 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"] 677 pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); 678 vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, Flags); 679 impl ExternalMemoryFeatureFlags { 680 pub const DEDICATED_ONLY: Self = Self(0b1); 681 pub const EXPORTABLE: Self = Self(0b10); 682 pub const IMPORTABLE: Self = Self(0b100); 683 } 684 #[repr(transparent)] 685 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 686 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"] 687 pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); 688 vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, Flags); 689 impl ExternalSemaphoreHandleTypeFlags { 690 pub const OPAQUE_FD: Self = Self(0b1); 691 pub const OPAQUE_WIN32: Self = Self(0b10); 692 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 693 pub const D3D12_FENCE: Self = Self(0b1000); 694 pub const D3D11_FENCE: Self = Self::D3D12_FENCE; 695 pub const SYNC_FD: Self = Self(0b1_0000); 696 } 697 #[repr(transparent)] 698 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 699 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"] 700 pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); 701 vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, Flags); 702 impl ExternalSemaphoreFeatureFlags { 703 pub const EXPORTABLE: Self = Self(0b1); 704 pub const IMPORTABLE: Self = Self(0b10); 705 } 706 #[repr(transparent)] 707 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 708 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreImportFlagBits.html>"] 709 pub struct SemaphoreImportFlags(pub(crate) Flags); 710 vk_bitflags_wrapped!(SemaphoreImportFlags, Flags); 711 impl SemaphoreImportFlags { 712 pub const TEMPORARY: Self = Self(0b1); 713 } 714 #[repr(transparent)] 715 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 716 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"] 717 pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); 718 vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, Flags); 719 impl ExternalFenceHandleTypeFlags { 720 pub const OPAQUE_FD: Self = Self(0b1); 721 pub const OPAQUE_WIN32: Self = Self(0b10); 722 pub const OPAQUE_WIN32_KMT: Self = Self(0b100); 723 pub const SYNC_FD: Self = Self(0b1000); 724 } 725 #[repr(transparent)] 726 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 727 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"] 728 pub struct ExternalFenceFeatureFlags(pub(crate) Flags); 729 vk_bitflags_wrapped!(ExternalFenceFeatureFlags, Flags); 730 impl ExternalFenceFeatureFlags { 731 pub const EXPORTABLE: Self = Self(0b1); 732 pub const IMPORTABLE: Self = Self(0b10); 733 } 734 #[repr(transparent)] 735 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 736 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceImportFlagBits.html>"] 737 pub struct FenceImportFlags(pub(crate) Flags); 738 vk_bitflags_wrapped!(FenceImportFlags, Flags); 739 impl FenceImportFlags { 740 pub const TEMPORARY: Self = Self(0b1); 741 } 742 #[repr(transparent)] 743 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 744 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"] 745 pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); 746 vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, Flags); 747 impl SurfaceCounterFlagsEXT { 748 pub const VBLANK: Self = Self(0b1); 749 } 750 #[repr(transparent)] 751 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 752 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"] 753 pub struct PeerMemoryFeatureFlags(pub(crate) Flags); 754 vk_bitflags_wrapped!(PeerMemoryFeatureFlags, Flags); 755 impl PeerMemoryFeatureFlags { 756 #[doc = "Can read with vkCmdCopy commands"] 757 pub const COPY_SRC: Self = Self(0b1); 758 #[doc = "Can write with vkCmdCopy commands"] 759 pub const COPY_DST: Self = Self(0b10); 760 #[doc = "Can read with any access type/command"] 761 pub const GENERIC_SRC: Self = Self(0b100); 762 #[doc = "Can write with and access type/command"] 763 pub const GENERIC_DST: Self = Self(0b1000); 764 } 765 #[repr(transparent)] 766 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 767 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagBits.html>"] 768 pub struct MemoryAllocateFlags(pub(crate) Flags); 769 vk_bitflags_wrapped!(MemoryAllocateFlags, Flags); 770 impl MemoryAllocateFlags { 771 #[doc = "Force allocation on specific devices"] 772 pub const DEVICE_MASK: Self = Self(0b1); 773 } 774 #[repr(transparent)] 775 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 776 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html>"] 777 pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); 778 vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, Flags); 779 impl DeviceGroupPresentModeFlagsKHR { 780 #[doc = "Present from local memory"] 781 pub const LOCAL: Self = Self(0b1); 782 #[doc = "Present from remote memory"] 783 pub const REMOTE: Self = Self(0b10); 784 #[doc = "Present sum of local and/or remote memory"] 785 pub const SUM: Self = Self(0b100); 786 #[doc = "Each physical device presents from local memory"] 787 pub const LOCAL_MULTI_DEVICE: Self = Self(0b1000); 788 } 789 #[repr(transparent)] 790 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 791 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"] 792 pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); 793 vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, Flags); 794 impl SwapchainCreateFlagsKHR {} 795 #[repr(transparent)] 796 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 797 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionFlagBits.html>"] 798 pub struct SubpassDescriptionFlags(pub(crate) Flags); 799 vk_bitflags_wrapped!(SubpassDescriptionFlags, Flags); 800 impl SubpassDescriptionFlags {} 801 #[repr(transparent)] 802 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 803 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"] 804 pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); 805 vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, Flags); 806 impl DebugUtilsMessageSeverityFlagsEXT { 807 pub const VERBOSE: Self = Self(0b1); 808 pub const INFO: Self = Self(0b1_0000); 809 pub const WARNING: Self = Self(0b1_0000_0000); 810 pub const ERROR: Self = Self(0b1_0000_0000_0000); 811 } 812 #[repr(transparent)] 813 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 814 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"] 815 pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); 816 vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, Flags); 817 impl DebugUtilsMessageTypeFlagsEXT { 818 pub const GENERAL: Self = Self(0b1); 819 pub const VALIDATION: Self = Self(0b10); 820 pub const PERFORMANCE: Self = Self(0b100); 821 } 822 #[repr(transparent)] 823 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 824 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBindingFlagBits.html>"] 825 pub struct DescriptorBindingFlags(pub(crate) Flags); 826 vk_bitflags_wrapped!(DescriptorBindingFlags, Flags); 827 impl DescriptorBindingFlags { 828 pub const UPDATE_AFTER_BIND: Self = Self(0b1); 829 pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(0b10); 830 pub const PARTIALLY_BOUND: Self = Self(0b100); 831 pub const VARIABLE_DESCRIPTOR_COUNT: Self = Self(0b1000); 832 } 833 #[repr(transparent)] 834 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 835 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"] 836 pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags); 837 vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, Flags); 838 impl ConditionalRenderingFlagsEXT { 839 pub const INVERTED: Self = Self(0b1); 840 } 841 #[repr(transparent)] 842 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 843 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveModeFlagBits.html>"] 844 pub struct ResolveModeFlags(pub(crate) Flags); 845 vk_bitflags_wrapped!(ResolveModeFlags, Flags); 846 impl ResolveModeFlags { 847 pub const NONE: Self = Self(0); 848 pub const SAMPLE_ZERO: Self = Self(0b1); 849 pub const AVERAGE: Self = Self(0b10); 850 pub const MIN: Self = Self(0b100); 851 pub const MAX: Self = Self(0b1000); 852 } 853 #[repr(transparent)] 854 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 855 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"] 856 pub struct GeometryInstanceFlagsKHR(pub(crate) Flags); 857 vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, Flags); 858 impl GeometryInstanceFlagsKHR { 859 pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(0b1); 860 pub const TRIANGLE_FLIP_FACING: Self = Self(0b10); 861 pub const FORCE_OPAQUE: Self = Self(0b100); 862 pub const FORCE_NO_OPAQUE: Self = Self(0b1000); 863 pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = Self::TRIANGLE_FLIP_FACING; 864 } 865 #[repr(transparent)] 866 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 867 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryFlagBitsKHR.html>"] 868 pub struct GeometryFlagsKHR(pub(crate) Flags); 869 vk_bitflags_wrapped!(GeometryFlagsKHR, Flags); 870 impl GeometryFlagsKHR { 871 pub const OPAQUE: Self = Self(0b1); 872 pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(0b10); 873 } 874 #[repr(transparent)] 875 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 876 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"] 877 pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags); 878 vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, Flags); 879 impl BuildAccelerationStructureFlagsKHR { 880 pub const ALLOW_UPDATE: Self = Self(0b1); 881 pub const ALLOW_COMPACTION: Self = Self(0b10); 882 pub const PREFER_FAST_TRACE: Self = Self(0b100); 883 pub const PREFER_FAST_BUILD: Self = Self(0b1000); 884 pub const LOW_MEMORY: Self = Self(0b1_0000); 885 } 886 #[repr(transparent)] 887 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 888 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateFlagBitsKHR.html>"] 889 pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags); 890 vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, Flags); 891 impl AccelerationStructureCreateFlagsKHR { 892 pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); 893 } 894 #[repr(transparent)] 895 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 896 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateFlagBits.html>"] 897 pub struct FramebufferCreateFlags(pub(crate) Flags); 898 vk_bitflags_wrapped!(FramebufferCreateFlags, Flags); 899 impl FramebufferCreateFlags {} 900 #[repr(transparent)] 901 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 902 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"] 903 pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags); 904 vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, Flags); 905 impl DeviceDiagnosticsConfigFlagsNV { 906 pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1); 907 pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10); 908 pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(0b100); 909 pub const ENABLE_SHADER_ERROR_REPORTING: Self = Self(0b1000); 910 } 911 #[repr(transparent)] 912 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 913 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackFlagBits.html>"] 914 pub struct PipelineCreationFeedbackFlags(pub(crate) Flags); 915 vk_bitflags_wrapped!(PipelineCreationFeedbackFlags, Flags); 916 impl PipelineCreationFeedbackFlags { 917 pub const VALID: Self = Self(0b1); 918 pub const VALID_EXT: Self = Self::VALID; 919 pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10); 920 pub const APPLICATION_PIPELINE_CACHE_HIT_EXT: Self = Self::APPLICATION_PIPELINE_CACHE_HIT; 921 pub const BASE_PIPELINE_ACCELERATION: Self = Self(0b100); 922 pub const BASE_PIPELINE_ACCELERATION_EXT: Self = Self::BASE_PIPELINE_ACCELERATION; 923 } 924 #[repr(transparent)] 925 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 926 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDecompressionMethodFlagBitsNV.html>"] 927 pub struct MemoryDecompressionMethodFlagsNV(pub(crate) Flags64); 928 vk_bitflags_wrapped!(MemoryDecompressionMethodFlagsNV, Flags64); 929 impl MemoryDecompressionMethodFlagsNV { 930 pub const GDEFLATE_1_0: Self = Self(0b1); 931 } 932 #[repr(transparent)] 933 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 934 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"] 935 pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags); 936 vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, Flags); 937 impl PerformanceCounterDescriptionFlagsKHR { 938 pub const PERFORMANCE_IMPACTING: Self = Self(0b1); 939 pub const CONCURRENTLY_IMPACTED: Self = Self(0b10); 940 } 941 #[repr(transparent)] 942 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 943 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"] 944 pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags); 945 vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, Flags); 946 impl AcquireProfilingLockFlagsKHR {} 947 #[repr(transparent)] 948 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 949 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"] 950 pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags); 951 vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, Flags); 952 impl ShaderCorePropertiesFlagsAMD {} 953 #[repr(transparent)] 954 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 955 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateFlagBits.html>"] 956 pub struct ShaderModuleCreateFlags(pub(crate) Flags); 957 vk_bitflags_wrapped!(ShaderModuleCreateFlags, Flags); 958 impl ShaderModuleCreateFlags {} 959 #[repr(transparent)] 960 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 961 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"] 962 pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags); 963 vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, Flags); 964 impl PipelineCompilerControlFlagsAMD {} 965 #[repr(transparent)] 966 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 967 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkToolPurposeFlagBits.html>"] 968 pub struct ToolPurposeFlags(pub(crate) Flags); 969 vk_bitflags_wrapped!(ToolPurposeFlags, Flags); 970 impl ToolPurposeFlags { 971 pub const VALIDATION: Self = Self(0b1); 972 pub const VALIDATION_EXT: Self = Self::VALIDATION; 973 pub const PROFILING: Self = Self(0b10); 974 pub const PROFILING_EXT: Self = Self::PROFILING; 975 pub const TRACING: Self = Self(0b100); 976 pub const TRACING_EXT: Self = Self::TRACING; 977 pub const ADDITIONAL_FEATURES: Self = Self(0b1000); 978 pub const ADDITIONAL_FEATURES_EXT: Self = Self::ADDITIONAL_FEATURES; 979 pub const MODIFYING_FEATURES: Self = Self(0b1_0000); 980 pub const MODIFYING_FEATURES_EXT: Self = Self::MODIFYING_FEATURES; 981 } 982 #[repr(transparent)] 983 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 984 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccessFlagBits2.html>"] 985 pub struct AccessFlags2(pub(crate) Flags64); 986 vk_bitflags_wrapped!(AccessFlags2, Flags64); 987 impl AccessFlags2 { 988 pub const NONE: Self = Self(0); 989 pub const NONE_KHR: Self = Self::NONE; 990 pub const INDIRECT_COMMAND_READ: Self = Self(0b1); 991 pub const INDIRECT_COMMAND_READ_KHR: Self = Self::INDIRECT_COMMAND_READ; 992 pub const INDEX_READ: Self = Self(0b10); 993 pub const INDEX_READ_KHR: Self = Self::INDEX_READ; 994 pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100); 995 pub const VERTEX_ATTRIBUTE_READ_KHR: Self = Self::VERTEX_ATTRIBUTE_READ; 996 pub const UNIFORM_READ: Self = Self(0b1000); 997 pub const UNIFORM_READ_KHR: Self = Self::UNIFORM_READ; 998 pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000); 999 pub const INPUT_ATTACHMENT_READ_KHR: Self = Self::INPUT_ATTACHMENT_READ; 1000 pub const SHADER_READ: Self = Self(0b10_0000); 1001 pub const SHADER_READ_KHR: Self = Self::SHADER_READ; 1002 pub const SHADER_WRITE: Self = Self(0b100_0000); 1003 pub const SHADER_WRITE_KHR: Self = Self::SHADER_WRITE; 1004 pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000); 1005 pub const COLOR_ATTACHMENT_READ_KHR: Self = Self::COLOR_ATTACHMENT_READ; 1006 pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000); 1007 pub const COLOR_ATTACHMENT_WRITE_KHR: Self = Self::COLOR_ATTACHMENT_WRITE; 1008 pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000); 1009 pub const DEPTH_STENCIL_ATTACHMENT_READ_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT_READ; 1010 pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000); 1011 pub const DEPTH_STENCIL_ATTACHMENT_WRITE_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT_WRITE; 1012 pub const TRANSFER_READ: Self = Self(0b1000_0000_0000); 1013 pub const TRANSFER_READ_KHR: Self = Self::TRANSFER_READ; 1014 pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000); 1015 pub const TRANSFER_WRITE_KHR: Self = Self::TRANSFER_WRITE; 1016 pub const HOST_READ: Self = Self(0b10_0000_0000_0000); 1017 pub const HOST_READ_KHR: Self = Self::HOST_READ; 1018 pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000); 1019 pub const HOST_WRITE_KHR: Self = Self::HOST_WRITE; 1020 pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000); 1021 pub const MEMORY_READ_KHR: Self = Self::MEMORY_READ; 1022 pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000); 1023 pub const MEMORY_WRITE_KHR: Self = Self::MEMORY_WRITE; 1024 pub const SHADER_SAMPLED_READ: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); 1025 pub const SHADER_SAMPLED_READ_KHR: Self = Self::SHADER_SAMPLED_READ; 1026 pub const SHADER_STORAGE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); 1027 pub const SHADER_STORAGE_READ_KHR: Self = Self::SHADER_STORAGE_READ; 1028 pub const SHADER_STORAGE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); 1029 pub const SHADER_STORAGE_WRITE_KHR: Self = Self::SHADER_STORAGE_WRITE; 1030 } 1031 #[repr(transparent)] 1032 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1033 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineStageFlagBits2.html>"] 1034 pub struct PipelineStageFlags2(pub(crate) Flags64); 1035 vk_bitflags_wrapped!(PipelineStageFlags2, Flags64); 1036 impl PipelineStageFlags2 { 1037 pub const NONE: Self = Self(0); 1038 pub const NONE_KHR: Self = Self::NONE; 1039 pub const TOP_OF_PIPE: Self = Self(0b1); 1040 pub const TOP_OF_PIPE_KHR: Self = Self::TOP_OF_PIPE; 1041 pub const DRAW_INDIRECT: Self = Self(0b10); 1042 pub const DRAW_INDIRECT_KHR: Self = Self::DRAW_INDIRECT; 1043 pub const VERTEX_INPUT: Self = Self(0b100); 1044 pub const VERTEX_INPUT_KHR: Self = Self::VERTEX_INPUT; 1045 pub const VERTEX_SHADER: Self = Self(0b1000); 1046 pub const VERTEX_SHADER_KHR: Self = Self::VERTEX_SHADER; 1047 pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); 1048 pub const TESSELLATION_CONTROL_SHADER_KHR: Self = Self::TESSELLATION_CONTROL_SHADER; 1049 pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); 1050 pub const TESSELLATION_EVALUATION_SHADER_KHR: Self = Self::TESSELLATION_EVALUATION_SHADER; 1051 pub const GEOMETRY_SHADER: Self = Self(0b100_0000); 1052 pub const GEOMETRY_SHADER_KHR: Self = Self::GEOMETRY_SHADER; 1053 pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); 1054 pub const FRAGMENT_SHADER_KHR: Self = Self::FRAGMENT_SHADER; 1055 pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); 1056 pub const EARLY_FRAGMENT_TESTS_KHR: Self = Self::EARLY_FRAGMENT_TESTS; 1057 pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); 1058 pub const LATE_FRAGMENT_TESTS_KHR: Self = Self::LATE_FRAGMENT_TESTS; 1059 pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); 1060 pub const COLOR_ATTACHMENT_OUTPUT_KHR: Self = Self::COLOR_ATTACHMENT_OUTPUT; 1061 pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); 1062 pub const COMPUTE_SHADER_KHR: Self = Self::COMPUTE_SHADER; 1063 pub const ALL_TRANSFER: Self = Self(0b1_0000_0000_0000); 1064 pub const ALL_TRANSFER_KHR: Self = Self::ALL_TRANSFER; 1065 pub const TRANSFER: Self = Self::ALL_TRANSFER_KHR; 1066 pub const TRANSFER_KHR: Self = Self::ALL_TRANSFER; 1067 pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); 1068 pub const BOTTOM_OF_PIPE_KHR: Self = Self::BOTTOM_OF_PIPE; 1069 pub const HOST: Self = Self(0b100_0000_0000_0000); 1070 pub const HOST_KHR: Self = Self::HOST; 1071 pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); 1072 pub const ALL_GRAPHICS_KHR: Self = Self::ALL_GRAPHICS; 1073 pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); 1074 pub const ALL_COMMANDS_KHR: Self = Self::ALL_COMMANDS; 1075 pub const COPY: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); 1076 pub const COPY_KHR: Self = Self::COPY; 1077 pub const RESOLVE: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); 1078 pub const RESOLVE_KHR: Self = Self::RESOLVE; 1079 pub const BLIT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); 1080 pub const BLIT_KHR: Self = Self::BLIT; 1081 pub const CLEAR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); 1082 pub const CLEAR_KHR: Self = Self::CLEAR; 1083 pub const INDEX_INPUT: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1084 pub const INDEX_INPUT_KHR: Self = Self::INDEX_INPUT; 1085 pub const VERTEX_ATTRIBUTE_INPUT: Self = 1086 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1087 pub const VERTEX_ATTRIBUTE_INPUT_KHR: Self = Self::VERTEX_ATTRIBUTE_INPUT; 1088 pub const PRE_RASTERIZATION_SHADERS: Self = 1089 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1090 pub const PRE_RASTERIZATION_SHADERS_KHR: Self = Self::PRE_RASTERIZATION_SHADERS; 1091 } 1092 #[repr(transparent)] 1093 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1094 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitFlagBits.html>"] 1095 pub struct SubmitFlags(pub(crate) Flags); 1096 vk_bitflags_wrapped!(SubmitFlags, Flags); 1097 impl SubmitFlags { 1098 pub const PROTECTED: Self = Self(0b1); 1099 pub const PROTECTED_KHR: Self = Self::PROTECTED; 1100 } 1101 #[repr(transparent)] 1102 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1103 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateFlagBits.html>"] 1104 pub struct EventCreateFlags(pub(crate) Flags); 1105 vk_bitflags_wrapped!(EventCreateFlags, Flags); 1106 impl EventCreateFlags {} 1107 #[repr(transparent)] 1108 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1109 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateFlagBits.html>"] 1110 pub struct PipelineLayoutCreateFlags(pub(crate) Flags); 1111 vk_bitflags_wrapped!(PipelineLayoutCreateFlags, Flags); 1112 impl PipelineLayoutCreateFlags {} 1113 #[repr(transparent)] 1114 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1115 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateFlagBits.html>"] 1116 pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags); 1117 vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, Flags); 1118 impl PipelineColorBlendStateCreateFlags {} 1119 #[repr(transparent)] 1120 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1121 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateFlagBits.html>"] 1122 pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags); 1123 vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, Flags); 1124 impl PipelineDepthStencilStateCreateFlags {} 1125 #[repr(transparent)] 1126 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1127 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineLibraryFlagBitsEXT.html>"] 1128 pub struct GraphicsPipelineLibraryFlagsEXT(pub(crate) Flags); 1129 vk_bitflags_wrapped!(GraphicsPipelineLibraryFlagsEXT, Flags); 1130 impl GraphicsPipelineLibraryFlagsEXT { 1131 pub const VERTEX_INPUT_INTERFACE: Self = Self(0b1); 1132 pub const PRE_RASTERIZATION_SHADERS: Self = Self(0b10); 1133 pub const FRAGMENT_SHADER: Self = Self(0b100); 1134 pub const FRAGMENT_OUTPUT_INTERFACE: Self = Self(0b1000); 1135 } 1136 #[repr(transparent)] 1137 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1138 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddressBindingFlagBitsEXT.html>"] 1139 pub struct DeviceAddressBindingFlagsEXT(pub(crate) Flags); 1140 vk_bitflags_wrapped!(DeviceAddressBindingFlagsEXT, Flags); 1141 impl DeviceAddressBindingFlagsEXT { 1142 pub const INTERNAL_OBJECT: Self = Self(0b1); 1143 } 1144 #[repr(transparent)] 1145 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1146 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentScalingFlagBitsEXT.html>"] 1147 pub struct PresentScalingFlagsEXT(pub(crate) Flags); 1148 vk_bitflags_wrapped!(PresentScalingFlagsEXT, Flags); 1149 impl PresentScalingFlagsEXT { 1150 pub const ONE_TO_ONE: Self = Self(0b1); 1151 pub const ASPECT_RATIO_STRETCH: Self = Self(0b10); 1152 pub const STRETCH: Self = Self(0b100); 1153 } 1154 #[repr(transparent)] 1155 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1156 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentGravityFlagBitsEXT.html>"] 1157 pub struct PresentGravityFlagsEXT(pub(crate) Flags); 1158 vk_bitflags_wrapped!(PresentGravityFlagsEXT, Flags); 1159 impl PresentGravityFlagsEXT { 1160 pub const MIN: Self = Self(0b1); 1161 pub const MAX: Self = Self(0b10); 1162 pub const CENTERED: Self = Self(0b100); 1163 } 1164 #[repr(transparent)] 1165 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1166 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"] 1167 pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); 1168 vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags); 1169 impl VideoCodecOperationFlagsKHR { 1170 pub const NONE: Self = Self(0); 1171 } 1172 #[repr(transparent)] 1173 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1174 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html>"] 1175 pub struct VideoChromaSubsamplingFlagsKHR(pub(crate) Flags); 1176 vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, Flags); 1177 impl VideoChromaSubsamplingFlagsKHR { 1178 pub const INVALID: Self = Self(0); 1179 pub const MONOCHROME: Self = Self(0b1); 1180 pub const TYPE_420: Self = Self(0b10); 1181 pub const TYPE_422: Self = Self(0b100); 1182 pub const TYPE_444: Self = Self(0b1000); 1183 } 1184 #[repr(transparent)] 1185 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1186 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoComponentBitDepthFlagBitsKHR.html>"] 1187 pub struct VideoComponentBitDepthFlagsKHR(pub(crate) Flags); 1188 vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, Flags); 1189 impl VideoComponentBitDepthFlagsKHR { 1190 pub const INVALID: Self = Self(0); 1191 pub const TYPE_8: Self = Self(0b1); 1192 pub const TYPE_10: Self = Self(0b100); 1193 pub const TYPE_12: Self = Self(0b1_0000); 1194 } 1195 #[repr(transparent)] 1196 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1197 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilityFlagBitsKHR.html>"] 1198 pub struct VideoCapabilityFlagsKHR(pub(crate) Flags); 1199 vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, Flags); 1200 impl VideoCapabilityFlagsKHR { 1201 pub const PROTECTED_CONTENT: Self = Self(0b1); 1202 pub const SEPARATE_REFERENCE_IMAGES: Self = Self(0b10); 1203 } 1204 #[repr(transparent)] 1205 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1206 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateFlagBitsKHR.html>"] 1207 pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags); 1208 vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, Flags); 1209 impl VideoSessionCreateFlagsKHR { 1210 pub const PROTECTED_CONTENT: Self = Self(0b1); 1211 } 1212 #[repr(transparent)] 1213 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1214 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsKHR.html>"] 1215 pub struct VideoDecodeH264PictureLayoutFlagsKHR(pub(crate) Flags); 1216 vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsKHR, Flags); 1217 impl VideoDecodeH264PictureLayoutFlagsKHR { 1218 pub const PROGRESSIVE: Self = Self(0); 1219 pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1); 1220 pub const INTERLACED_SEPARATE_PLANES: Self = Self(0b10); 1221 } 1222 #[repr(transparent)] 1223 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1224 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlFlagBitsKHR.html>"] 1225 pub struct VideoCodingControlFlagsKHR(pub(crate) Flags); 1226 vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, Flags); 1227 impl VideoCodingControlFlagsKHR { 1228 pub const RESET: Self = Self(0b1); 1229 } 1230 #[repr(transparent)] 1231 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1232 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeUsageFlagBitsKHR.html>"] 1233 pub struct VideoDecodeUsageFlagsKHR(pub(crate) Flags); 1234 vk_bitflags_wrapped!(VideoDecodeUsageFlagsKHR, Flags); 1235 impl VideoDecodeUsageFlagsKHR { 1236 pub const DEFAULT: Self = Self(0); 1237 pub const TRANSCODING: Self = Self(0b1); 1238 pub const OFFLINE: Self = Self(0b10); 1239 pub const STREAMING: Self = Self(0b100); 1240 } 1241 #[repr(transparent)] 1242 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1243 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilityFlagBitsKHR.html>"] 1244 pub struct VideoDecodeCapabilityFlagsKHR(pub(crate) Flags); 1245 vk_bitflags_wrapped!(VideoDecodeCapabilityFlagsKHR, Flags); 1246 impl VideoDecodeCapabilityFlagsKHR { 1247 pub const DPB_AND_OUTPUT_COINCIDE: Self = Self(0b1); 1248 pub const DPB_AND_OUTPUT_DISTINCT: Self = Self(0b10); 1249 } 1250 #[repr(transparent)] 1251 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1252 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeUsageFlagBitsKHR.html>"] 1253 pub struct VideoEncodeUsageFlagsKHR(pub(crate) Flags); 1254 vk_bitflags_wrapped!(VideoEncodeUsageFlagsKHR, Flags); 1255 impl VideoEncodeUsageFlagsKHR { 1256 pub const DEFAULT: Self = Self(0); 1257 pub const TRANSCODING: Self = Self(0b1); 1258 pub const STREAMING: Self = Self(0b10); 1259 pub const RECORDING: Self = Self(0b100); 1260 pub const CONFERENCING: Self = Self(0b1000); 1261 } 1262 #[repr(transparent)] 1263 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1264 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeContentFlagBitsKHR.html>"] 1265 pub struct VideoEncodeContentFlagsKHR(pub(crate) Flags); 1266 vk_bitflags_wrapped!(VideoEncodeContentFlagsKHR, Flags); 1267 impl VideoEncodeContentFlagsKHR { 1268 pub const DEFAULT: Self = Self(0); 1269 pub const CAMERA: Self = Self(0b1); 1270 pub const DESKTOP: Self = Self(0b10); 1271 pub const RENDERED: Self = Self(0b100); 1272 } 1273 #[repr(transparent)] 1274 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1275 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeCapabilityFlagBitsKHR.html>"] 1276 pub struct VideoEncodeCapabilityFlagsKHR(pub(crate) Flags); 1277 vk_bitflags_wrapped!(VideoEncodeCapabilityFlagsKHR, Flags); 1278 impl VideoEncodeCapabilityFlagsKHR { 1279 pub const PRECEDING_EXTERNALLY_ENCODED_BYTES: Self = Self(0b1); 1280 } 1281 #[repr(transparent)] 1282 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1283 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeFeedbackFlagBitsKHR.html>"] 1284 pub struct VideoEncodeFeedbackFlagsKHR(pub(crate) Flags); 1285 vk_bitflags_wrapped!(VideoEncodeFeedbackFlagsKHR, Flags); 1286 impl VideoEncodeFeedbackFlagsKHR { 1287 pub const BITSTREAM_BUFFER_OFFSET: Self = Self(0b1); 1288 pub const BITSTREAM_BYTES_WRITTEN: Self = Self(0b10); 1289 } 1290 #[repr(transparent)] 1291 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1292 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html>"] 1293 pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags); 1294 vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, Flags); 1295 impl VideoEncodeRateControlModeFlagsKHR { 1296 pub const DEFAULT: Self = Self(0); 1297 pub const DISABLED: Self = Self(0b1); 1298 pub const CBR: Self = Self(0b10); 1299 pub const VBR: Self = Self(0b100); 1300 } 1301 #[repr(transparent)] 1302 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1303 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264CapabilityFlagBitsEXT.html>"] 1304 pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags); 1305 vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags); 1306 impl VideoEncodeH264CapabilityFlagsEXT { 1307 pub const DIRECT_8X8_INFERENCE_ENABLED: Self = Self(0b1); 1308 pub const DIRECT_8X8_INFERENCE_DISABLED: Self = Self(0b10); 1309 pub const SEPARATE_COLOUR_PLANE: Self = Self(0b100); 1310 pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b1000); 1311 pub const SCALING_LISTS: Self = Self(0b1_0000); 1312 pub const HRD_COMPLIANCE: Self = Self(0b10_0000); 1313 pub const CHROMA_QP_OFFSET: Self = Self(0b100_0000); 1314 pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b1000_0000); 1315 pub const PIC_INIT_QP_MINUS26: Self = Self(0b1_0000_0000); 1316 pub const WEIGHTED_PRED: Self = Self(0b10_0000_0000); 1317 pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b100_0000_0000); 1318 pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b1000_0000_0000); 1319 pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1_0000_0000_0000); 1320 pub const TRANSFORM_8X8: Self = Self(0b10_0000_0000_0000); 1321 pub const CABAC: Self = Self(0b100_0000_0000_0000); 1322 pub const CAVLC: Self = Self(0b1000_0000_0000_0000); 1323 pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1_0000_0000_0000_0000); 1324 pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b10_0000_0000_0000_0000); 1325 pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b100_0000_0000_0000_0000); 1326 pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b1000_0000_0000_0000_0000); 1327 pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1_0000_0000_0000_0000_0000); 1328 pub const SLICE_MB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); 1329 pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000); 1330 pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000); 1331 pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000); 1332 pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b10_0000_0000_0000_0000_0000_0000); 1333 } 1334 #[repr(transparent)] 1335 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1336 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html>"] 1337 pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags); 1338 vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags); 1339 impl ImageFormatConstraintsFlagsFUCHSIA {} 1340 #[repr(transparent)] 1341 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1342 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html>"] 1343 pub struct ImageConstraintsInfoFlagsFUCHSIA(pub(crate) Flags); 1344 vk_bitflags_wrapped!(ImageConstraintsInfoFlagsFUCHSIA, Flags); 1345 impl ImageConstraintsInfoFlagsFUCHSIA { 1346 pub const CPU_READ_RARELY: Self = Self(0b1); 1347 pub const CPU_READ_OFTEN: Self = Self(0b10); 1348 pub const CPU_WRITE_RARELY: Self = Self(0b100); 1349 pub const CPU_WRITE_OFTEN: Self = Self(0b1000); 1350 pub const PROTECTED_OPTIONAL: Self = Self(0b1_0000); 1351 } 1352 #[repr(transparent)] 1353 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1354 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatFeatureFlagBits2.html>"] 1355 pub struct FormatFeatureFlags2(pub(crate) Flags64); 1356 vk_bitflags_wrapped!(FormatFeatureFlags2, Flags64); 1357 impl FormatFeatureFlags2 { 1358 pub const SAMPLED_IMAGE: Self = Self(0b1); 1359 pub const SAMPLED_IMAGE_KHR: Self = Self::SAMPLED_IMAGE; 1360 pub const STORAGE_IMAGE: Self = Self(0b10); 1361 pub const STORAGE_IMAGE_KHR: Self = Self::STORAGE_IMAGE; 1362 pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); 1363 pub const STORAGE_IMAGE_ATOMIC_KHR: Self = Self::STORAGE_IMAGE_ATOMIC; 1364 pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); 1365 pub const UNIFORM_TEXEL_BUFFER_KHR: Self = Self::UNIFORM_TEXEL_BUFFER; 1366 pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); 1367 pub const STORAGE_TEXEL_BUFFER_KHR: Self = Self::STORAGE_TEXEL_BUFFER; 1368 pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); 1369 pub const STORAGE_TEXEL_BUFFER_ATOMIC_KHR: Self = Self::STORAGE_TEXEL_BUFFER_ATOMIC; 1370 pub const VERTEX_BUFFER: Self = Self(0b100_0000); 1371 pub const VERTEX_BUFFER_KHR: Self = Self::VERTEX_BUFFER; 1372 pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); 1373 pub const COLOR_ATTACHMENT_KHR: Self = Self::COLOR_ATTACHMENT; 1374 pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); 1375 pub const COLOR_ATTACHMENT_BLEND_KHR: Self = Self::COLOR_ATTACHMENT_BLEND; 1376 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); 1377 pub const DEPTH_STENCIL_ATTACHMENT_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT; 1378 pub const BLIT_SRC: Self = Self(0b100_0000_0000); 1379 pub const BLIT_SRC_KHR: Self = Self::BLIT_SRC; 1380 pub const BLIT_DST: Self = Self(0b1000_0000_0000); 1381 pub const BLIT_DST_KHR: Self = Self::BLIT_DST; 1382 pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); 1383 pub const SAMPLED_IMAGE_FILTER_LINEAR_KHR: Self = Self::SAMPLED_IMAGE_FILTER_LINEAR; 1384 pub const SAMPLED_IMAGE_FILTER_CUBIC: Self = Self(0b10_0000_0000_0000); 1385 pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC; 1386 pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000); 1387 pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC; 1388 pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000); 1389 pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST; 1390 pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000); 1391 pub const SAMPLED_IMAGE_FILTER_MINMAX_KHR: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX; 1392 pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000); 1393 pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES; 1394 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000); 1395 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self = 1396 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER; 1397 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = 1398 Self(0b1000_0000_0000_0000_0000); 1399 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self = 1400 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER; 1401 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = 1402 Self(0b1_0000_0000_0000_0000_0000); 1403 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self = 1404 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT; 1405 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = 1406 Self(0b10_0000_0000_0000_0000_0000); 1407 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self = 1408 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE; 1409 pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000); 1410 pub const DISJOINT_KHR: Self = Self::DISJOINT; 1411 pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000); 1412 pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES; 1413 pub const STORAGE_READ_WITHOUT_FORMAT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000); 1414 pub const STORAGE_READ_WITHOUT_FORMAT_KHR: Self = Self::STORAGE_READ_WITHOUT_FORMAT; 1415 pub const STORAGE_WRITE_WITHOUT_FORMAT: Self = 1416 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); 1417 pub const STORAGE_WRITE_WITHOUT_FORMAT_KHR: Self = Self::STORAGE_WRITE_WITHOUT_FORMAT; 1418 pub const SAMPLED_IMAGE_DEPTH_COMPARISON: Self = 1419 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); 1420 pub const SAMPLED_IMAGE_DEPTH_COMPARISON_KHR: Self = Self::SAMPLED_IMAGE_DEPTH_COMPARISON; 1421 } 1422 #[repr(transparent)] 1423 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1424 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFlagBits.html>"] 1425 pub struct RenderingFlags(pub(crate) Flags); 1426 vk_bitflags_wrapped!(RenderingFlags, Flags); 1427 impl RenderingFlags { 1428 pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(0b1); 1429 pub const CONTENTS_SECONDARY_COMMAND_BUFFERS_KHR: Self = 1430 Self::CONTENTS_SECONDARY_COMMAND_BUFFERS; 1431 pub const SUSPENDING: Self = Self(0b10); 1432 pub const SUSPENDING_KHR: Self = Self::SUSPENDING; 1433 pub const RESUMING: Self = Self(0b100); 1434 pub const RESUMING_KHR: Self = Self::RESUMING; 1435 } 1436 #[repr(transparent)] 1437 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1438 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CapabilityFlagBitsEXT.html>"] 1439 pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags); 1440 vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, Flags); 1441 impl VideoEncodeH265CapabilityFlagsEXT { 1442 pub const SEPARATE_COLOUR_PLANE: Self = Self(0b1); 1443 pub const SCALING_LISTS: Self = Self(0b10); 1444 pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED: Self = Self(0b100); 1445 pub const PCM_ENABLE: Self = Self(0b1000); 1446 pub const SPS_TEMPORAL_MVP_ENABLED: Self = Self(0b1_0000); 1447 pub const HRD_COMPLIANCE: Self = Self(0b10_0000); 1448 pub const INIT_QP_MINUS26: Self = Self(0b100_0000); 1449 pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1000_0000); 1450 pub const SIGN_DATA_HIDING_ENABLED: Self = Self(0b1_0000_0000); 1451 pub const TRANSFORM_SKIP_ENABLED: Self = Self(0b10_0000_0000); 1452 pub const TRANSFORM_SKIP_DISABLED: Self = Self(0b100_0000_0000); 1453 pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT: Self = Self(0b1000_0000_0000); 1454 pub const WEIGHTED_PRED: Self = Self(0b1_0000_0000_0000); 1455 pub const WEIGHTED_BIPRED: Self = Self(0b10_0000_0000_0000); 1456 pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b100_0000_0000_0000); 1457 pub const TRANSQUANT_BYPASS_ENABLED: Self = Self(0b1000_0000_0000_0000); 1458 pub const ENTROPY_CODING_SYNC_ENABLED: Self = Self(0b1_0000_0000_0000_0000); 1459 pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED: Self = Self(0b10_0000_0000_0000_0000); 1460 pub const MULTIPLE_TILE_PER_FRAME: Self = Self(0b100_0000_0000_0000_0000); 1461 pub const MULTIPLE_SLICE_PER_TILE: Self = Self(0b1000_0000_0000_0000_0000); 1462 pub const MULTIPLE_TILE_PER_SLICE: Self = Self(0b1_0000_0000_0000_0000_0000); 1463 pub const SLICE_SEGMENT_CTB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); 1464 pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100_0000_0000_0000_0000_0000); 1465 pub const DEPENDENT_SLICE_SEGMENT: Self = Self(0b1000_0000_0000_0000_0000_0000); 1466 pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1_0000_0000_0000_0000_0000_0000); 1467 pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000_0000_0000_0000_0000_0000); 1468 pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b100_0000_0000_0000_0000_0000_0000); 1469 } 1470 #[repr(transparent)] 1471 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1472 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CtbSizeFlagBitsEXT.html>"] 1473 pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags); 1474 vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, Flags); 1475 impl VideoEncodeH265CtbSizeFlagsEXT { 1476 pub const TYPE_16: Self = Self(0b1); 1477 pub const TYPE_32: Self = Self(0b10); 1478 pub const TYPE_64: Self = Self(0b100); 1479 } 1480 #[repr(transparent)] 1481 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1482 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265TransformBlockSizeFlagBitsEXT.html>"] 1483 pub struct VideoEncodeH265TransformBlockSizeFlagsEXT(pub(crate) Flags); 1484 vk_bitflags_wrapped!(VideoEncodeH265TransformBlockSizeFlagsEXT, Flags); 1485 impl VideoEncodeH265TransformBlockSizeFlagsEXT { 1486 pub const TYPE_4: Self = Self(0b1); 1487 pub const TYPE_8: Self = Self(0b10); 1488 pub const TYPE_16: Self = Self(0b100); 1489 pub const TYPE_32: Self = Self(0b1000); 1490 } 1491 #[repr(transparent)] 1492 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1493 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectTypeFlagBitsEXT.html>"] 1494 pub struct ExportMetalObjectTypeFlagsEXT(pub(crate) Flags); 1495 vk_bitflags_wrapped!(ExportMetalObjectTypeFlagsEXT, Flags); 1496 impl ExportMetalObjectTypeFlagsEXT { 1497 pub const METAL_DEVICE: Self = Self(0b1); 1498 pub const METAL_COMMAND_QUEUE: Self = Self(0b10); 1499 pub const METAL_BUFFER: Self = Self(0b100); 1500 pub const METAL_TEXTURE: Self = Self(0b1000); 1501 pub const METAL_IOSURFACE: Self = Self(0b1_0000); 1502 pub const METAL_SHARED_EVENT: Self = Self(0b10_0000); 1503 } 1504 #[repr(transparent)] 1505 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1506 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateFlagBits.html>"] 1507 pub struct InstanceCreateFlags(pub(crate) Flags); 1508 vk_bitflags_wrapped!(InstanceCreateFlags, Flags); 1509 impl InstanceCreateFlags {} 1510 #[repr(transparent)] 1511 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1512 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFlagBitsEXT.html>"] 1513 pub struct ImageCompressionFlagsEXT(pub(crate) Flags); 1514 vk_bitflags_wrapped!(ImageCompressionFlagsEXT, Flags); 1515 impl ImageCompressionFlagsEXT { 1516 pub const DEFAULT: Self = Self(0); 1517 pub const FIXED_RATE_DEFAULT: Self = Self(0b1); 1518 pub const FIXED_RATE_EXPLICIT: Self = Self(0b10); 1519 pub const DISABLED: Self = Self(0b100); 1520 } 1521 #[repr(transparent)] 1522 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1523 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFixedRateFlagBitsEXT.html>"] 1524 pub struct ImageCompressionFixedRateFlagsEXT(pub(crate) Flags); 1525 vk_bitflags_wrapped!(ImageCompressionFixedRateFlagsEXT, Flags); 1526 impl ImageCompressionFixedRateFlagsEXT { 1527 pub const NONE: Self = Self(0); 1528 pub const TYPE_1BPC: Self = Self(0b1); 1529 pub const TYPE_2BPC: Self = Self(0b10); 1530 pub const TYPE_3BPC: Self = Self(0b100); 1531 pub const TYPE_4BPC: Self = Self(0b1000); 1532 pub const TYPE_5BPC: Self = Self(0b1_0000); 1533 pub const TYPE_6BPC: Self = Self(0b10_0000); 1534 pub const TYPE_7BPC: Self = Self(0b100_0000); 1535 pub const TYPE_8BPC: Self = Self(0b1000_0000); 1536 pub const TYPE_9BPC: Self = Self(0b1_0000_0000); 1537 pub const TYPE_10BPC: Self = Self(0b10_0000_0000); 1538 pub const TYPE_11BPC: Self = Self(0b100_0000_0000); 1539 pub const TYPE_12BPC: Self = Self(0b1000_0000_0000); 1540 pub const TYPE_13BPC: Self = Self(0b1_0000_0000_0000); 1541 pub const TYPE_14BPC: Self = Self(0b10_0000_0000_0000); 1542 pub const TYPE_15BPC: Self = Self(0b100_0000_0000_0000); 1543 pub const TYPE_16BPC: Self = Self(0b1000_0000_0000_0000); 1544 pub const TYPE_17BPC: Self = Self(0b1_0000_0000_0000_0000); 1545 pub const TYPE_18BPC: Self = Self(0b10_0000_0000_0000_0000); 1546 pub const TYPE_19BPC: Self = Self(0b100_0000_0000_0000_0000); 1547 pub const TYPE_20BPC: Self = Self(0b1000_0000_0000_0000_0000); 1548 pub const TYPE_21BPC: Self = Self(0b1_0000_0000_0000_0000_0000); 1549 pub const TYPE_22BPC: Self = Self(0b10_0000_0000_0000_0000_0000); 1550 pub const TYPE_23BPC: Self = Self(0b100_0000_0000_0000_0000_0000); 1551 pub const TYPE_24BPC: Self = Self(0b1000_0000_0000_0000_0000_0000); 1552 } 1553 #[repr(transparent)] 1554 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1555 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowGridSizeFlagBitsNV.html>"] 1556 pub struct OpticalFlowGridSizeFlagsNV(pub(crate) Flags); 1557 vk_bitflags_wrapped!(OpticalFlowGridSizeFlagsNV, Flags); 1558 impl OpticalFlowGridSizeFlagsNV { 1559 pub const UNKNOWN: Self = Self(0); 1560 pub const TYPE_1X1: Self = Self(0b1); 1561 pub const TYPE_2X2: Self = Self(0b10); 1562 pub const TYPE_4X4: Self = Self(0b100); 1563 pub const TYPE_8X8: Self = Self(0b1000); 1564 } 1565 #[repr(transparent)] 1566 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1567 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowUsageFlagBitsNV.html>"] 1568 pub struct OpticalFlowUsageFlagsNV(pub(crate) Flags); 1569 vk_bitflags_wrapped!(OpticalFlowUsageFlagsNV, Flags); 1570 impl OpticalFlowUsageFlagsNV { 1571 pub const UNKNOWN: Self = Self(0); 1572 pub const INPUT: Self = Self(0b1); 1573 pub const OUTPUT: Self = Self(0b10); 1574 pub const HINT: Self = Self(0b100); 1575 pub const COST: Self = Self(0b1000); 1576 pub const GLOBAL_FLOW: Self = Self(0b1_0000); 1577 } 1578 #[repr(transparent)] 1579 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1580 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreateFlagBitsNV.html>"] 1581 pub struct OpticalFlowSessionCreateFlagsNV(pub(crate) Flags); 1582 vk_bitflags_wrapped!(OpticalFlowSessionCreateFlagsNV, Flags); 1583 impl OpticalFlowSessionCreateFlagsNV { 1584 pub const ENABLE_HINT: Self = Self(0b1); 1585 pub const ENABLE_COST: Self = Self(0b10); 1586 pub const ENABLE_GLOBAL_FLOW: Self = Self(0b100); 1587 pub const ALLOW_REGIONS: Self = Self(0b1000); 1588 pub const BOTH_DIRECTIONS: Self = Self(0b1_0000); 1589 } 1590 #[repr(transparent)] 1591 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1592 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowExecuteFlagBitsNV.html>"] 1593 pub struct OpticalFlowExecuteFlagsNV(pub(crate) Flags); 1594 vk_bitflags_wrapped!(OpticalFlowExecuteFlagsNV, Flags); 1595 impl OpticalFlowExecuteFlagsNV { 1596 pub const DISABLE_TEMPORAL_HINTS: Self = Self(0b1); 1597 } 1598 #[repr(transparent)] 1599 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1600 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildMicromapFlagBitsEXT.html>"] 1601 pub struct BuildMicromapFlagsEXT(pub(crate) Flags); 1602 vk_bitflags_wrapped!(BuildMicromapFlagsEXT, Flags); 1603 impl BuildMicromapFlagsEXT { 1604 pub const PREFER_FAST_TRACE: Self = Self(0b1); 1605 pub const PREFER_FAST_BUILD: Self = Self(0b10); 1606 pub const ALLOW_COMPACTION: Self = Self(0b100); 1607 } 1608 #[repr(transparent)] 1609 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1610 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapCreateFlagBitsEXT.html>"] 1611 pub struct MicromapCreateFlagsEXT(pub(crate) Flags); 1612 vk_bitflags_wrapped!(MicromapCreateFlagsEXT, Flags); 1613 impl MicromapCreateFlagsEXT { 1614 pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); 1615 } 1616 #[repr(transparent)] 1617 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1618 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCreateFlagBitsEXT.html>"] 1619 pub struct ShaderCreateFlagsEXT(pub(crate) Flags); 1620 vk_bitflags_wrapped!(ShaderCreateFlagsEXT, Flags); 1621 impl ShaderCreateFlagsEXT { 1622 pub const LINK_STAGE: Self = Self(0b1); 1623 } 1624