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, 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, 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, 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, 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, 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, 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, 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, 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, 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, Flags); 143 impl BufferCreateFlags { 144 #[doc = "Buffer should support sparse backing"] 145 pub const SPARSE_BINDING: Self = Self(0b1); 146 #[doc = "Buffer should support sparse backing with partial residency"] 147 pub const SPARSE_RESIDENCY: Self = Self(0b10); 148 #[doc = "Buffer should support constant data access to physical memory ranges mapped into multiple locations of sparse buffers"] 149 pub const SPARSE_ALIASED: Self = Self(0b100); 150 } 151 #[repr(transparent)] 152 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 153 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStageFlagBits.html>"] 154 pub struct ShaderStageFlags(pub(crate) Flags); 155 vk_bitflags_wrapped!(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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-extensions/man/html/VkPrivateDataSlotCreateFlagBitsEXT.html>"] 651 pub struct PrivateDataSlotCreateFlagsEXT(pub(crate) Flags); 652 vk_bitflags_wrapped!(PrivateDataSlotCreateFlagsEXT, Flags); 653 impl PrivateDataSlotCreateFlagsEXT {} 654 #[repr(transparent)] 655 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 656 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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.2-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 } 910 #[repr(transparent)] 911 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 912 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackFlagBitsEXT.html>"] 913 pub struct PipelineCreationFeedbackFlagsEXT(pub(crate) Flags); 914 vk_bitflags_wrapped!(PipelineCreationFeedbackFlagsEXT, Flags); 915 impl PipelineCreationFeedbackFlagsEXT { 916 pub const VALID: Self = Self(0b1); 917 pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10); 918 pub const BASE_PIPELINE_ACCELERATION: Self = Self(0b100); 919 } 920 #[repr(transparent)] 921 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 922 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"] 923 pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags); 924 vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, Flags); 925 impl PerformanceCounterDescriptionFlagsKHR { 926 pub const PERFORMANCE_IMPACTING: Self = Self(0b1); 927 pub const CONCURRENTLY_IMPACTED: Self = Self(0b10); 928 } 929 #[repr(transparent)] 930 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 931 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"] 932 pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags); 933 vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, Flags); 934 impl AcquireProfilingLockFlagsKHR {} 935 #[repr(transparent)] 936 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 937 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"] 938 pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags); 939 vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, Flags); 940 impl ShaderCorePropertiesFlagsAMD {} 941 #[repr(transparent)] 942 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 943 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateFlagBits.html>"] 944 pub struct ShaderModuleCreateFlags(pub(crate) Flags); 945 vk_bitflags_wrapped!(ShaderModuleCreateFlags, Flags); 946 impl ShaderModuleCreateFlags {} 947 #[repr(transparent)] 948 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 949 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"] 950 pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags); 951 vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, Flags); 952 impl PipelineCompilerControlFlagsAMD {} 953 #[repr(transparent)] 954 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 955 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkToolPurposeFlagBitsEXT.html>"] 956 pub struct ToolPurposeFlagsEXT(pub(crate) Flags); 957 vk_bitflags_wrapped!(ToolPurposeFlagsEXT, Flags); 958 impl ToolPurposeFlagsEXT { 959 pub const VALIDATION: Self = Self(0b1); 960 pub const PROFILING: Self = Self(0b10); 961 pub const TRACING: Self = Self(0b100); 962 pub const ADDITIONAL_FEATURES: Self = Self(0b1000); 963 pub const MODIFYING_FEATURES: Self = Self(0b1_0000); 964 } 965 #[repr(transparent)] 966 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 967 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits2KHR.html>"] 968 pub struct AccessFlags2KHR(pub(crate) Flags64); 969 vk_bitflags_wrapped!(AccessFlags2KHR, Flags64); 970 impl AccessFlags2KHR { 971 pub const NONE: Self = Self(0); 972 pub const INDIRECT_COMMAND_READ: Self = Self(0b1); 973 pub const INDEX_READ: Self = Self(0b10); 974 pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100); 975 pub const UNIFORM_READ: Self = Self(0b1000); 976 pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000); 977 pub const SHADER_READ: Self = Self(0b10_0000); 978 pub const SHADER_WRITE: Self = Self(0b100_0000); 979 pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000); 980 pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000); 981 pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000); 982 pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000); 983 pub const TRANSFER_READ: Self = Self(0b1000_0000_0000); 984 pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000); 985 pub const HOST_READ: Self = Self(0b10_0000_0000_0000); 986 pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000); 987 pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000); 988 pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000); 989 pub const SHADER_SAMPLED_READ: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); 990 pub const SHADER_STORAGE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); 991 pub const SHADER_STORAGE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); 992 } 993 #[repr(transparent)] 994 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 995 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits2KHR.html>"] 996 pub struct PipelineStageFlags2KHR(pub(crate) Flags64); 997 vk_bitflags_wrapped!(PipelineStageFlags2KHR, Flags64); 998 impl PipelineStageFlags2KHR { 999 pub const NONE: Self = Self(0); 1000 pub const TOP_OF_PIPE: Self = Self(0b1); 1001 pub const DRAW_INDIRECT: Self = Self(0b10); 1002 pub const VERTEX_INPUT: Self = Self(0b100); 1003 pub const VERTEX_SHADER: Self = Self(0b1000); 1004 pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); 1005 pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); 1006 pub const GEOMETRY_SHADER: Self = Self(0b100_0000); 1007 pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); 1008 pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); 1009 pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); 1010 pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); 1011 pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); 1012 pub const ALL_TRANSFER: Self = Self(0b1_0000_0000_0000); 1013 pub const TRANSFER: Self = Self::ALL_TRANSFER; 1014 pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); 1015 pub const HOST: Self = Self(0b100_0000_0000_0000); 1016 pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); 1017 pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); 1018 pub const COPY: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); 1019 pub const RESOLVE: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); 1020 pub const BLIT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); 1021 pub const CLEAR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); 1022 pub const INDEX_INPUT: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1023 pub const VERTEX_ATTRIBUTE_INPUT: Self = 1024 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1025 pub const PRE_RASTERIZATION_SHADERS: Self = 1026 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); 1027 } 1028 #[repr(transparent)] 1029 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1030 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitFlagBitsKHR.html>"] 1031 pub struct SubmitFlagsKHR(pub(crate) Flags); 1032 vk_bitflags_wrapped!(SubmitFlagsKHR, Flags); 1033 impl SubmitFlagsKHR { 1034 pub const PROTECTED: Self = Self(0b1); 1035 } 1036 #[repr(transparent)] 1037 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1038 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateFlagBits.html>"] 1039 pub struct EventCreateFlags(pub(crate) Flags); 1040 vk_bitflags_wrapped!(EventCreateFlags, Flags); 1041 impl EventCreateFlags {} 1042 #[repr(transparent)] 1043 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1044 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateFlagBits.html>"] 1045 pub struct PipelineLayoutCreateFlags(pub(crate) Flags); 1046 vk_bitflags_wrapped!(PipelineLayoutCreateFlags, Flags); 1047 impl PipelineLayoutCreateFlags {} 1048 #[repr(transparent)] 1049 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1050 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateFlagBits.html>"] 1051 pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags); 1052 vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, Flags); 1053 impl PipelineColorBlendStateCreateFlags {} 1054 #[repr(transparent)] 1055 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1056 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateFlagBits.html>"] 1057 pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags); 1058 vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, Flags); 1059 impl PipelineDepthStencilStateCreateFlags {} 1060 #[repr(transparent)] 1061 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1062 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"] 1063 pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); 1064 vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags); 1065 impl VideoCodecOperationFlagsKHR { 1066 pub const INVALID: Self = Self(0); 1067 } 1068 #[repr(transparent)] 1069 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1070 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html>"] 1071 pub struct VideoChromaSubsamplingFlagsKHR(pub(crate) Flags); 1072 vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, Flags); 1073 impl VideoChromaSubsamplingFlagsKHR { 1074 pub const INVALID: Self = Self(0); 1075 pub const MONOCHROME: Self = Self(0b1); 1076 pub const TYPE_420: Self = Self(0b10); 1077 pub const TYPE_422: Self = Self(0b100); 1078 pub const TYPE_444: Self = Self(0b1000); 1079 } 1080 #[repr(transparent)] 1081 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1082 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoComponentBitDepthFlagBitsKHR.html>"] 1083 pub struct VideoComponentBitDepthFlagsKHR(pub(crate) Flags); 1084 vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, Flags); 1085 impl VideoComponentBitDepthFlagsKHR { 1086 pub const INVALID: Self = Self(0); 1087 pub const TYPE_8: Self = Self(0b1); 1088 pub const TYPE_10: Self = Self(0b100); 1089 pub const TYPE_12: Self = Self(0b1_0000); 1090 } 1091 #[repr(transparent)] 1092 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1093 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCapabilityFlagBitsKHR.html>"] 1094 pub struct VideoCapabilityFlagsKHR(pub(crate) Flags); 1095 vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, Flags); 1096 impl VideoCapabilityFlagsKHR { 1097 pub const PROTECTED_CONTENT: Self = Self(0b1); 1098 pub const SEPARATE_REFERENCE_IMAGES: Self = Self(0b10); 1099 } 1100 #[repr(transparent)] 1101 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1102 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionCreateFlagBitsKHR.html>"] 1103 pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags); 1104 vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, Flags); 1105 impl VideoSessionCreateFlagsKHR { 1106 pub const DEFAULT: Self = Self(0); 1107 pub const PROTECTED_CONTENT: Self = Self(0b1); 1108 } 1109 #[repr(transparent)] 1110 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1111 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingQualityPresetFlagBitsKHR.html>"] 1112 pub struct VideoCodingQualityPresetFlagsKHR(pub(crate) Flags); 1113 vk_bitflags_wrapped!(VideoCodingQualityPresetFlagsKHR, Flags); 1114 impl VideoCodingQualityPresetFlagsKHR { 1115 pub const NORMAL: Self = Self(0b1); 1116 pub const POWER: Self = Self(0b10); 1117 pub const QUALITY: Self = Self(0b100); 1118 } 1119 #[repr(transparent)] 1120 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1121 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsEXT.html>"] 1122 pub struct VideoDecodeH264PictureLayoutFlagsEXT(pub(crate) Flags); 1123 vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsEXT, Flags); 1124 impl VideoDecodeH264PictureLayoutFlagsEXT { 1125 pub const PROGRESSIVE: Self = Self(0); 1126 pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1); 1127 pub const INTERLACED_SEPARATE_PLANES: Self = Self(0b10); 1128 } 1129 #[repr(transparent)] 1130 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1131 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingControlFlagBitsKHR.html>"] 1132 pub struct VideoCodingControlFlagsKHR(pub(crate) Flags); 1133 vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, Flags); 1134 impl VideoCodingControlFlagsKHR { 1135 pub const DEFAULT: Self = Self(0); 1136 pub const RESET: Self = Self(0b1); 1137 } 1138 #[repr(transparent)] 1139 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1140 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeFlagBitsKHR.html>"] 1141 pub struct VideoDecodeFlagsKHR(pub(crate) Flags); 1142 vk_bitflags_wrapped!(VideoDecodeFlagsKHR, Flags); 1143 impl VideoDecodeFlagsKHR { 1144 pub const DEFAULT: Self = Self(0); 1145 pub const RESERVED_0: Self = Self(0b1); 1146 } 1147 #[repr(transparent)] 1148 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1149 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeFlagBitsKHR.html>"] 1150 pub struct VideoEncodeFlagsKHR(pub(crate) Flags); 1151 vk_bitflags_wrapped!(VideoEncodeFlagsKHR, Flags); 1152 impl VideoEncodeFlagsKHR { 1153 pub const DEFAULT: Self = Self(0); 1154 pub const RESERVED_0: Self = Self(0b1); 1155 } 1156 #[repr(transparent)] 1157 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1158 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlFlagBitsKHR.html>"] 1159 pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags); 1160 vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags); 1161 impl VideoEncodeRateControlFlagsKHR { 1162 pub const DEFAULT: Self = Self(0); 1163 pub const RESERVED_0: Self = Self(0b1); 1164 } 1165 #[repr(transparent)] 1166 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1167 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html>"] 1168 pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags); 1169 vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, Flags); 1170 impl VideoEncodeRateControlModeFlagsKHR { 1171 pub const NONE: Self = Self(0); 1172 pub const CBR: Self = Self(1); 1173 pub const VBR: Self = Self(2); 1174 } 1175 #[repr(transparent)] 1176 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1177 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CapabilityFlagBitsEXT.html>"] 1178 pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags); 1179 vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags); 1180 impl VideoEncodeH264CapabilityFlagsEXT { 1181 pub const CABAC: Self = Self(0b1); 1182 pub const CAVLC: Self = Self(0b10); 1183 pub const WEIGHTED_BI_PRED_IMPLICIT: Self = Self(0b100); 1184 pub const TRANSFORM_8X8: Self = Self(0b1000); 1185 pub const CHROMA_QP_OFFSET: Self = Self(0b1_0000); 1186 pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b10_0000); 1187 pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b100_0000); 1188 pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b1000_0000); 1189 pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b1_0000_0000); 1190 pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b10_0000_0000); 1191 pub const EVENLY_DISTRIBUTED_SLICE_SIZE: Self = Self(0b100_0000_0000); 1192 } 1193 #[repr(transparent)] 1194 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1195 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264InputModeFlagBitsEXT.html>"] 1196 pub struct VideoEncodeH264InputModeFlagsEXT(pub(crate) Flags); 1197 vk_bitflags_wrapped!(VideoEncodeH264InputModeFlagsEXT, Flags); 1198 impl VideoEncodeH264InputModeFlagsEXT { 1199 pub const FRAME: Self = Self(0b1); 1200 pub const SLICE: Self = Self(0b10); 1201 pub const NON_VCL: Self = Self(0b100); 1202 } 1203 #[repr(transparent)] 1204 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1205 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264OutputModeFlagBitsEXT.html>"] 1206 pub struct VideoEncodeH264OutputModeFlagsEXT(pub(crate) Flags); 1207 vk_bitflags_wrapped!(VideoEncodeH264OutputModeFlagsEXT, Flags); 1208 impl VideoEncodeH264OutputModeFlagsEXT { 1209 pub const FRAME: Self = Self(0b1); 1210 pub const SLICE: Self = Self(0b10); 1211 pub const NON_VCL: Self = Self(0b100); 1212 } 1213 #[repr(transparent)] 1214 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1215 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CreateFlagBitsEXT.html>"] 1216 pub struct VideoEncodeH264CreateFlagsEXT(pub(crate) Flags); 1217 vk_bitflags_wrapped!(VideoEncodeH264CreateFlagsEXT, Flags); 1218 impl VideoEncodeH264CreateFlagsEXT { 1219 pub const DEFAULT: Self = Self(0); 1220 pub const RESERVED_0: Self = Self(0b1); 1221 } 1222 #[repr(transparent)] 1223 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1224 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264RateControlStructureFlagBitsEXT.html>"] 1225 pub struct VideoEncodeH264RateControlStructureFlagsEXT(pub(crate) Flags); 1226 vk_bitflags_wrapped!(VideoEncodeH264RateControlStructureFlagsEXT, Flags); 1227 impl VideoEncodeH264RateControlStructureFlagsEXT { 1228 pub const UNKNOWN: Self = Self(0); 1229 pub const FLAT: Self = Self(0b1); 1230 pub const DYADIC: Self = Self(0b10); 1231 } 1232 #[repr(transparent)] 1233 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1234 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html>"] 1235 pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags); 1236 vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags); 1237 impl ImageFormatConstraintsFlagsFUCHSIA {} 1238 #[repr(transparent)] 1239 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1240 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html>"] 1241 pub struct ImageConstraintsInfoFlagsFUCHSIA(pub(crate) Flags); 1242 vk_bitflags_wrapped!(ImageConstraintsInfoFlagsFUCHSIA, Flags); 1243 impl ImageConstraintsInfoFlagsFUCHSIA { 1244 pub const CPU_READ_RARELY: Self = Self(0b1); 1245 pub const CPU_READ_OFTEN: Self = Self(0b10); 1246 pub const CPU_WRITE_RARELY: Self = Self(0b100); 1247 pub const CPU_WRITE_OFTEN: Self = Self(0b1000); 1248 pub const PROTECTED_OPTIONAL: Self = Self(0b1_0000); 1249 } 1250 #[repr(transparent)] 1251 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1252 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits2KHR.html>"] 1253 pub struct FormatFeatureFlags2KHR(pub(crate) Flags64); 1254 vk_bitflags_wrapped!(FormatFeatureFlags2KHR, Flags64); 1255 impl FormatFeatureFlags2KHR { 1256 pub const SAMPLED_IMAGE: Self = Self(0b1); 1257 pub const STORAGE_IMAGE: Self = Self(0b10); 1258 pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); 1259 pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); 1260 pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); 1261 pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); 1262 pub const VERTEX_BUFFER: Self = Self(0b100_0000); 1263 pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); 1264 pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); 1265 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); 1266 pub const BLIT_SRC: Self = Self(0b100_0000_0000); 1267 pub const BLIT_DST: Self = Self(0b1000_0000_0000); 1268 pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); 1269 pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self(0b10_0000_0000_0000); 1270 pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000); 1271 pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000); 1272 pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000); 1273 pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000); 1274 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000); 1275 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = 1276 Self(0b1000_0000_0000_0000_0000); 1277 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = 1278 Self(0b1_0000_0000_0000_0000_0000); 1279 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = 1280 Self(0b10_0000_0000_0000_0000_0000); 1281 pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000); 1282 pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000); 1283 pub const STORAGE_READ_WITHOUT_FORMAT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000); 1284 pub const STORAGE_WRITE_WITHOUT_FORMAT: Self = 1285 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); 1286 pub const SAMPLED_IMAGE_DEPTH_COMPARISON: Self = 1287 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); 1288 } 1289 #[repr(transparent)] 1290 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1291 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265InputModeFlagBitsEXT.html>"] 1292 pub struct VideoEncodeH265InputModeFlagsEXT(pub(crate) Flags); 1293 vk_bitflags_wrapped!(VideoEncodeH265InputModeFlagsEXT, Flags); 1294 impl VideoEncodeH265InputModeFlagsEXT { 1295 pub const FRAME: Self = Self(0b1); 1296 pub const SLICE: Self = Self(0b10); 1297 pub const NON_VCL: Self = Self(0b100); 1298 } 1299 #[repr(transparent)] 1300 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1301 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265OutputModeFlagBitsEXT.html>"] 1302 pub struct VideoEncodeH265OutputModeFlagsEXT(pub(crate) Flags); 1303 vk_bitflags_wrapped!(VideoEncodeH265OutputModeFlagsEXT, Flags); 1304 impl VideoEncodeH265OutputModeFlagsEXT { 1305 pub const FRAME: Self = Self(0b1); 1306 pub const SLICE: Self = Self(0b10); 1307 pub const NON_VCL: Self = Self(0b100); 1308 } 1309 #[repr(transparent)] 1310 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1311 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265CtbSizeFlagBitsEXT.html>"] 1312 pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags); 1313 vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, Flags); 1314 impl VideoEncodeH265CtbSizeFlagsEXT { 1315 pub const TYPE_8: Self = Self(0b1); 1316 pub const TYPE_16: Self = Self(0b10); 1317 pub const TYPE_32: Self = Self(0b100); 1318 pub const TYPE_64: Self = Self(0b1000); 1319 } 1320 #[repr(transparent)] 1321 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1322 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderingFlagBitsKHR.html>"] 1323 pub struct RenderingFlagsKHR(pub(crate) Flags); 1324 vk_bitflags_wrapped!(RenderingFlagsKHR, Flags); 1325 impl RenderingFlagsKHR { 1326 pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(0b1); 1327 pub const SUSPENDING: Self = Self(0b10); 1328 pub const RESUMING: Self = Self(0b100); 1329 } 1330 #[repr(transparent)] 1331 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] 1332 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265RateControlStructureFlagBitsEXT.html>"] 1333 pub struct VideoEncodeH265RateControlStructureFlagsEXT(pub(crate) Flags); 1334 vk_bitflags_wrapped!(VideoEncodeH265RateControlStructureFlagsEXT, Flags); 1335 impl VideoEncodeH265RateControlStructureFlagsEXT { 1336 pub const UNKNOWN: Self = Self(0); 1337 pub const FLAT: Self = Self(0b1); 1338 pub const DYADIC: Self = Self(0b10); 1339 } 1340