1#[doc(alias = "VK_MAX_PHYSICAL_DEVICE_NAME_SIZE")]
4pub const MAX_PHYSICAL_DEVICE_NAME_SIZE: u32 = 256;
5#[doc(alias = "VK_UUID_SIZE")]
7pub const UUID_SIZE: u32 = 16;
8#[doc(alias = "VK_MAX_EXTENSION_NAME_SIZE")]
10pub const MAX_EXTENSION_NAME_SIZE: u32 = 256;
11#[doc(alias = "VK_MAX_DESCRIPTION_SIZE")]
13pub const MAX_DESCRIPTION_SIZE: u32 = 256;
14#[doc(alias = "VK_MAX_MEMORY_TYPES")]
16pub const MAX_MEMORY_TYPES: u32 = 32;
17#[doc(alias = "VK_MAX_MEMORY_HEAPS")]
19pub const MAX_MEMORY_HEAPS: u32 = 16;
20#[doc(alias = "VK_LOD_CLAMP_NONE")]
22pub const LOD_CLAMP_NONE: f32 = 1000.0;
23#[doc(alias = "VK_REMAINING_MIP_LEVELS")]
25pub const REMAINING_MIP_LEVELS: u32 = 4294967295;
26#[doc(alias = "VK_REMAINING_ARRAY_LAYERS")]
28pub const REMAINING_ARRAY_LAYERS: u32 = 4294967295;
29#[doc(alias = "VK_WHOLE_SIZE")]
31pub const WHOLE_SIZE: u64 = 18446744073709551615;
32#[doc(alias = "VK_ATTACHMENT_UNUSED")]
34pub const ATTACHMENT_UNUSED: u32 = 4294967295;
35#[doc(alias = "VK_TRUE")]
37pub const TRUE: u32 = 1;
38#[doc(alias = "VK_FALSE")]
40pub const FALSE: u32 = 0;
41#[doc(alias = "VK_QUEUE_FAMILY_IGNORED")]
43pub const QUEUE_FAMILY_IGNORED: u32 = 4294967295;
44#[doc(alias = "VK_SUBPASS_EXTERNAL")]
46pub const SUBPASS_EXTERNAL: u32 = 4294967295;
47pub const FN_CREATE_INSTANCE: *const std::os::raw::c_char = crate::cstr!(
49 "vkCreateInstance"
50);
51pub const FN_DESTROY_INSTANCE: *const std::os::raw::c_char = crate::cstr!(
53 "vkDestroyInstance"
54);
55pub const FN_ENUMERATE_PHYSICAL_DEVICES: *const std::os::raw::c_char = crate::cstr!(
57 "vkEnumeratePhysicalDevices"
58);
59pub const FN_GET_DEVICE_PROC_ADDR: *const std::os::raw::c_char = crate::cstr!(
61 "vkGetDeviceProcAddr"
62);
63pub const FN_GET_INSTANCE_PROC_ADDR: *const std::os::raw::c_char = crate::cstr!(
65 "vkGetInstanceProcAddr"
66);
67pub const FN_GET_PHYSICAL_DEVICE_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
69 "vkGetPhysicalDeviceProperties"
70);
71pub const FN_GET_PHYSICAL_DEVICE_QUEUE_FAMILY_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
73 "vkGetPhysicalDeviceQueueFamilyProperties"
74);
75pub const FN_GET_PHYSICAL_DEVICE_MEMORY_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
77 "vkGetPhysicalDeviceMemoryProperties"
78);
79pub const FN_GET_PHYSICAL_DEVICE_FEATURES: *const std::os::raw::c_char = crate::cstr!(
81 "vkGetPhysicalDeviceFeatures"
82);
83pub const FN_GET_PHYSICAL_DEVICE_FORMAT_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
85 "vkGetPhysicalDeviceFormatProperties"
86);
87pub const FN_GET_PHYSICAL_DEVICE_IMAGE_FORMAT_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
89 "vkGetPhysicalDeviceImageFormatProperties"
90);
91pub const FN_CREATE_DEVICE: *const std::os::raw::c_char = crate::cstr!("vkCreateDevice");
93pub const FN_DESTROY_DEVICE: *const std::os::raw::c_char = crate::cstr!(
95 "vkDestroyDevice"
96);
97pub const FN_ENUMERATE_INSTANCE_LAYER_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
99 "vkEnumerateInstanceLayerProperties"
100);
101pub const FN_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
103 "vkEnumerateInstanceExtensionProperties"
104);
105pub const FN_ENUMERATE_DEVICE_LAYER_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
107 "vkEnumerateDeviceLayerProperties"
108);
109pub const FN_ENUMERATE_DEVICE_EXTENSION_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
111 "vkEnumerateDeviceExtensionProperties"
112);
113pub const FN_GET_DEVICE_QUEUE: *const std::os::raw::c_char = crate::cstr!(
115 "vkGetDeviceQueue"
116);
117pub const FN_QUEUE_SUBMIT: *const std::os::raw::c_char = crate::cstr!("vkQueueSubmit");
119pub const FN_QUEUE_WAIT_IDLE: *const std::os::raw::c_char = crate::cstr!(
121 "vkQueueWaitIdle"
122);
123pub const FN_DEVICE_WAIT_IDLE: *const std::os::raw::c_char = crate::cstr!(
125 "vkDeviceWaitIdle"
126);
127pub const FN_ALLOCATE_MEMORY: *const std::os::raw::c_char = crate::cstr!(
129 "vkAllocateMemory"
130);
131pub const FN_FREE_MEMORY: *const std::os::raw::c_char = crate::cstr!("vkFreeMemory");
133pub const FN_MAP_MEMORY: *const std::os::raw::c_char = crate::cstr!("vkMapMemory");
135pub const FN_UNMAP_MEMORY: *const std::os::raw::c_char = crate::cstr!("vkUnmapMemory");
137pub const FN_FLUSH_MAPPED_MEMORY_RANGES: *const std::os::raw::c_char = crate::cstr!(
139 "vkFlushMappedMemoryRanges"
140);
141pub const FN_INVALIDATE_MAPPED_MEMORY_RANGES: *const std::os::raw::c_char = crate::cstr!(
143 "vkInvalidateMappedMemoryRanges"
144);
145pub const FN_GET_DEVICE_MEMORY_COMMITMENT: *const std::os::raw::c_char = crate::cstr!(
147 "vkGetDeviceMemoryCommitment"
148);
149pub const FN_GET_BUFFER_MEMORY_REQUIREMENTS: *const std::os::raw::c_char = crate::cstr!(
151 "vkGetBufferMemoryRequirements"
152);
153pub const FN_BIND_BUFFER_MEMORY: *const std::os::raw::c_char = crate::cstr!(
155 "vkBindBufferMemory"
156);
157pub const FN_GET_IMAGE_MEMORY_REQUIREMENTS: *const std::os::raw::c_char = crate::cstr!(
159 "vkGetImageMemoryRequirements"
160);
161pub const FN_BIND_IMAGE_MEMORY: *const std::os::raw::c_char = crate::cstr!(
163 "vkBindImageMemory"
164);
165pub const FN_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS: *const std::os::raw::c_char = crate::cstr!(
167 "vkGetImageSparseMemoryRequirements"
168);
169pub const FN_GET_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_PROPERTIES: *const std::os::raw::c_char = crate::cstr!(
171 "vkGetPhysicalDeviceSparseImageFormatProperties"
172);
173pub const FN_QUEUE_BIND_SPARSE: *const std::os::raw::c_char = crate::cstr!(
175 "vkQueueBindSparse"
176);
177pub const FN_CREATE_FENCE: *const std::os::raw::c_char = crate::cstr!("vkCreateFence");
179pub const FN_DESTROY_FENCE: *const std::os::raw::c_char = crate::cstr!("vkDestroyFence");
181pub const FN_RESET_FENCES: *const std::os::raw::c_char = crate::cstr!("vkResetFences");
183pub const FN_GET_FENCE_STATUS: *const std::os::raw::c_char = crate::cstr!(
185 "vkGetFenceStatus"
186);
187pub const FN_WAIT_FOR_FENCES: *const std::os::raw::c_char = crate::cstr!(
189 "vkWaitForFences"
190);
191pub const FN_CREATE_SEMAPHORE: *const std::os::raw::c_char = crate::cstr!(
193 "vkCreateSemaphore"
194);
195pub const FN_DESTROY_SEMAPHORE: *const std::os::raw::c_char = crate::cstr!(
197 "vkDestroySemaphore"
198);
199pub const FN_CREATE_EVENT: *const std::os::raw::c_char = crate::cstr!("vkCreateEvent");
201pub const FN_DESTROY_EVENT: *const std::os::raw::c_char = crate::cstr!("vkDestroyEvent");
203pub const FN_GET_EVENT_STATUS: *const std::os::raw::c_char = crate::cstr!(
205 "vkGetEventStatus"
206);
207pub const FN_SET_EVENT: *const std::os::raw::c_char = crate::cstr!("vkSetEvent");
209pub const FN_RESET_EVENT: *const std::os::raw::c_char = crate::cstr!("vkResetEvent");
211pub const FN_CREATE_QUERY_POOL: *const std::os::raw::c_char = crate::cstr!(
213 "vkCreateQueryPool"
214);
215pub const FN_DESTROY_QUERY_POOL: *const std::os::raw::c_char = crate::cstr!(
217 "vkDestroyQueryPool"
218);
219pub const FN_GET_QUERY_POOL_RESULTS: *const std::os::raw::c_char = crate::cstr!(
221 "vkGetQueryPoolResults"
222);
223pub const FN_CREATE_BUFFER: *const std::os::raw::c_char = crate::cstr!("vkCreateBuffer");
225pub const FN_DESTROY_BUFFER: *const std::os::raw::c_char = crate::cstr!(
227 "vkDestroyBuffer"
228);
229pub const FN_CREATE_BUFFER_VIEW: *const std::os::raw::c_char = crate::cstr!(
231 "vkCreateBufferView"
232);
233pub const FN_DESTROY_BUFFER_VIEW: *const std::os::raw::c_char = crate::cstr!(
235 "vkDestroyBufferView"
236);
237pub const FN_CREATE_IMAGE: *const std::os::raw::c_char = crate::cstr!("vkCreateImage");
239pub const FN_DESTROY_IMAGE: *const std::os::raw::c_char = crate::cstr!("vkDestroyImage");
241pub const FN_GET_IMAGE_SUBRESOURCE_LAYOUT: *const std::os::raw::c_char = crate::cstr!(
243 "vkGetImageSubresourceLayout"
244);
245pub const FN_CREATE_IMAGE_VIEW: *const std::os::raw::c_char = crate::cstr!(
247 "vkCreateImageView"
248);
249pub const FN_DESTROY_IMAGE_VIEW: *const std::os::raw::c_char = crate::cstr!(
251 "vkDestroyImageView"
252);
253pub const FN_CREATE_SHADER_MODULE: *const std::os::raw::c_char = crate::cstr!(
255 "vkCreateShaderModule"
256);
257pub const FN_DESTROY_SHADER_MODULE: *const std::os::raw::c_char = crate::cstr!(
259 "vkDestroyShaderModule"
260);
261pub const FN_CREATE_PIPELINE_CACHE: *const std::os::raw::c_char = crate::cstr!(
263 "vkCreatePipelineCache"
264);
265pub const FN_DESTROY_PIPELINE_CACHE: *const std::os::raw::c_char = crate::cstr!(
267 "vkDestroyPipelineCache"
268);
269pub const FN_GET_PIPELINE_CACHE_DATA: *const std::os::raw::c_char = crate::cstr!(
271 "vkGetPipelineCacheData"
272);
273pub const FN_MERGE_PIPELINE_CACHES: *const std::os::raw::c_char = crate::cstr!(
275 "vkMergePipelineCaches"
276);
277pub const FN_CREATE_GRAPHICS_PIPELINES: *const std::os::raw::c_char = crate::cstr!(
279 "vkCreateGraphicsPipelines"
280);
281pub const FN_CREATE_COMPUTE_PIPELINES: *const std::os::raw::c_char = crate::cstr!(
283 "vkCreateComputePipelines"
284);
285pub const FN_DESTROY_PIPELINE: *const std::os::raw::c_char = crate::cstr!(
287 "vkDestroyPipeline"
288);
289pub const FN_CREATE_PIPELINE_LAYOUT: *const std::os::raw::c_char = crate::cstr!(
291 "vkCreatePipelineLayout"
292);
293pub const FN_DESTROY_PIPELINE_LAYOUT: *const std::os::raw::c_char = crate::cstr!(
295 "vkDestroyPipelineLayout"
296);
297pub const FN_CREATE_SAMPLER: *const std::os::raw::c_char = crate::cstr!(
299 "vkCreateSampler"
300);
301pub const FN_DESTROY_SAMPLER: *const std::os::raw::c_char = crate::cstr!(
303 "vkDestroySampler"
304);
305pub const FN_CREATE_DESCRIPTOR_SET_LAYOUT: *const std::os::raw::c_char = crate::cstr!(
307 "vkCreateDescriptorSetLayout"
308);
309pub const FN_DESTROY_DESCRIPTOR_SET_LAYOUT: *const std::os::raw::c_char = crate::cstr!(
311 "vkDestroyDescriptorSetLayout"
312);
313pub const FN_CREATE_DESCRIPTOR_POOL: *const std::os::raw::c_char = crate::cstr!(
315 "vkCreateDescriptorPool"
316);
317pub const FN_DESTROY_DESCRIPTOR_POOL: *const std::os::raw::c_char = crate::cstr!(
319 "vkDestroyDescriptorPool"
320);
321pub const FN_RESET_DESCRIPTOR_POOL: *const std::os::raw::c_char = crate::cstr!(
323 "vkResetDescriptorPool"
324);
325pub const FN_ALLOCATE_DESCRIPTOR_SETS: *const std::os::raw::c_char = crate::cstr!(
327 "vkAllocateDescriptorSets"
328);
329pub const FN_FREE_DESCRIPTOR_SETS: *const std::os::raw::c_char = crate::cstr!(
331 "vkFreeDescriptorSets"
332);
333pub const FN_UPDATE_DESCRIPTOR_SETS: *const std::os::raw::c_char = crate::cstr!(
335 "vkUpdateDescriptorSets"
336);
337pub const FN_CREATE_FRAMEBUFFER: *const std::os::raw::c_char = crate::cstr!(
339 "vkCreateFramebuffer"
340);
341pub const FN_DESTROY_FRAMEBUFFER: *const std::os::raw::c_char = crate::cstr!(
343 "vkDestroyFramebuffer"
344);
345pub const FN_CREATE_RENDER_PASS: *const std::os::raw::c_char = crate::cstr!(
347 "vkCreateRenderPass"
348);
349pub const FN_DESTROY_RENDER_PASS: *const std::os::raw::c_char = crate::cstr!(
351 "vkDestroyRenderPass"
352);
353pub const FN_GET_RENDER_AREA_GRANULARITY: *const std::os::raw::c_char = crate::cstr!(
355 "vkGetRenderAreaGranularity"
356);
357pub const FN_CREATE_COMMAND_POOL: *const std::os::raw::c_char = crate::cstr!(
359 "vkCreateCommandPool"
360);
361pub const FN_DESTROY_COMMAND_POOL: *const std::os::raw::c_char = crate::cstr!(
363 "vkDestroyCommandPool"
364);
365pub const FN_RESET_COMMAND_POOL: *const std::os::raw::c_char = crate::cstr!(
367 "vkResetCommandPool"
368);
369pub const FN_ALLOCATE_COMMAND_BUFFERS: *const std::os::raw::c_char = crate::cstr!(
371 "vkAllocateCommandBuffers"
372);
373pub const FN_FREE_COMMAND_BUFFERS: *const std::os::raw::c_char = crate::cstr!(
375 "vkFreeCommandBuffers"
376);
377pub const FN_BEGIN_COMMAND_BUFFER: *const std::os::raw::c_char = crate::cstr!(
379 "vkBeginCommandBuffer"
380);
381pub const FN_END_COMMAND_BUFFER: *const std::os::raw::c_char = crate::cstr!(
383 "vkEndCommandBuffer"
384);
385pub const FN_RESET_COMMAND_BUFFER: *const std::os::raw::c_char = crate::cstr!(
387 "vkResetCommandBuffer"
388);
389pub const FN_CMD_BIND_PIPELINE: *const std::os::raw::c_char = crate::cstr!(
391 "vkCmdBindPipeline"
392);
393pub const FN_CMD_SET_VIEWPORT: *const std::os::raw::c_char = crate::cstr!(
395 "vkCmdSetViewport"
396);
397pub const FN_CMD_SET_SCISSOR: *const std::os::raw::c_char = crate::cstr!(
399 "vkCmdSetScissor"
400);
401pub const FN_CMD_SET_LINE_WIDTH: *const std::os::raw::c_char = crate::cstr!(
403 "vkCmdSetLineWidth"
404);
405pub const FN_CMD_SET_DEPTH_BIAS: *const std::os::raw::c_char = crate::cstr!(
407 "vkCmdSetDepthBias"
408);
409pub const FN_CMD_SET_BLEND_CONSTANTS: *const std::os::raw::c_char = crate::cstr!(
411 "vkCmdSetBlendConstants"
412);
413pub const FN_CMD_SET_DEPTH_BOUNDS: *const std::os::raw::c_char = crate::cstr!(
415 "vkCmdSetDepthBounds"
416);
417pub const FN_CMD_SET_STENCIL_COMPARE_MASK: *const std::os::raw::c_char = crate::cstr!(
419 "vkCmdSetStencilCompareMask"
420);
421pub const FN_CMD_SET_STENCIL_WRITE_MASK: *const std::os::raw::c_char = crate::cstr!(
423 "vkCmdSetStencilWriteMask"
424);
425pub const FN_CMD_SET_STENCIL_REFERENCE: *const std::os::raw::c_char = crate::cstr!(
427 "vkCmdSetStencilReference"
428);
429pub const FN_CMD_BIND_DESCRIPTOR_SETS: *const std::os::raw::c_char = crate::cstr!(
431 "vkCmdBindDescriptorSets"
432);
433pub const FN_CMD_BIND_INDEX_BUFFER: *const std::os::raw::c_char = crate::cstr!(
435 "vkCmdBindIndexBuffer"
436);
437pub const FN_CMD_BIND_VERTEX_BUFFERS: *const std::os::raw::c_char = crate::cstr!(
439 "vkCmdBindVertexBuffers"
440);
441pub const FN_CMD_DRAW: *const std::os::raw::c_char = crate::cstr!("vkCmdDraw");
443pub const FN_CMD_DRAW_INDEXED: *const std::os::raw::c_char = crate::cstr!(
445 "vkCmdDrawIndexed"
446);
447pub const FN_CMD_DRAW_INDIRECT: *const std::os::raw::c_char = crate::cstr!(
449 "vkCmdDrawIndirect"
450);
451pub const FN_CMD_DRAW_INDEXED_INDIRECT: *const std::os::raw::c_char = crate::cstr!(
453 "vkCmdDrawIndexedIndirect"
454);
455pub const FN_CMD_DISPATCH: *const std::os::raw::c_char = crate::cstr!("vkCmdDispatch");
457pub const FN_CMD_DISPATCH_INDIRECT: *const std::os::raw::c_char = crate::cstr!(
459 "vkCmdDispatchIndirect"
460);
461pub const FN_CMD_COPY_BUFFER: *const std::os::raw::c_char = crate::cstr!(
463 "vkCmdCopyBuffer"
464);
465pub const FN_CMD_COPY_IMAGE: *const std::os::raw::c_char = crate::cstr!(
467 "vkCmdCopyImage"
468);
469pub const FN_CMD_BLIT_IMAGE: *const std::os::raw::c_char = crate::cstr!(
471 "vkCmdBlitImage"
472);
473pub const FN_CMD_COPY_BUFFER_TO_IMAGE: *const std::os::raw::c_char = crate::cstr!(
475 "vkCmdCopyBufferToImage"
476);
477pub const FN_CMD_COPY_IMAGE_TO_BUFFER: *const std::os::raw::c_char = crate::cstr!(
479 "vkCmdCopyImageToBuffer"
480);
481pub const FN_CMD_UPDATE_BUFFER: *const std::os::raw::c_char = crate::cstr!(
483 "vkCmdUpdateBuffer"
484);
485pub const FN_CMD_FILL_BUFFER: *const std::os::raw::c_char = crate::cstr!(
487 "vkCmdFillBuffer"
488);
489pub const FN_CMD_CLEAR_COLOR_IMAGE: *const std::os::raw::c_char = crate::cstr!(
491 "vkCmdClearColorImage"
492);
493pub const FN_CMD_CLEAR_DEPTH_STENCIL_IMAGE: *const std::os::raw::c_char = crate::cstr!(
495 "vkCmdClearDepthStencilImage"
496);
497pub const FN_CMD_CLEAR_ATTACHMENTS: *const std::os::raw::c_char = crate::cstr!(
499 "vkCmdClearAttachments"
500);
501pub const FN_CMD_RESOLVE_IMAGE: *const std::os::raw::c_char = crate::cstr!(
503 "vkCmdResolveImage"
504);
505pub const FN_CMD_SET_EVENT: *const std::os::raw::c_char = crate::cstr!("vkCmdSetEvent");
507pub const FN_CMD_RESET_EVENT: *const std::os::raw::c_char = crate::cstr!(
509 "vkCmdResetEvent"
510);
511pub const FN_CMD_WAIT_EVENTS: *const std::os::raw::c_char = crate::cstr!(
513 "vkCmdWaitEvents"
514);
515pub const FN_CMD_PIPELINE_BARRIER: *const std::os::raw::c_char = crate::cstr!(
517 "vkCmdPipelineBarrier"
518);
519pub const FN_CMD_BEGIN_QUERY: *const std::os::raw::c_char = crate::cstr!(
521 "vkCmdBeginQuery"
522);
523pub const FN_CMD_END_QUERY: *const std::os::raw::c_char = crate::cstr!("vkCmdEndQuery");
525pub const FN_CMD_RESET_QUERY_POOL: *const std::os::raw::c_char = crate::cstr!(
527 "vkCmdResetQueryPool"
528);
529pub const FN_CMD_WRITE_TIMESTAMP: *const std::os::raw::c_char = crate::cstr!(
531 "vkCmdWriteTimestamp"
532);
533pub const FN_CMD_COPY_QUERY_POOL_RESULTS: *const std::os::raw::c_char = crate::cstr!(
535 "vkCmdCopyQueryPoolResults"
536);
537pub const FN_CMD_PUSH_CONSTANTS: *const std::os::raw::c_char = crate::cstr!(
539 "vkCmdPushConstants"
540);
541pub const FN_CMD_BEGIN_RENDER_PASS: *const std::os::raw::c_char = crate::cstr!(
543 "vkCmdBeginRenderPass"
544);
545pub const FN_CMD_NEXT_SUBPASS: *const std::os::raw::c_char = crate::cstr!(
547 "vkCmdNextSubpass"
548);
549pub const FN_CMD_END_RENDER_PASS: *const std::os::raw::c_char = crate::cstr!(
551 "vkCmdEndRenderPass"
552);
553pub const FN_CMD_EXECUTE_COMMANDS: *const std::os::raw::c_char = crate::cstr!(
555 "vkCmdExecuteCommands"
556);
557#[doc(alias = "VkSampleMask")]
559pub type SampleMask = u32;
560#[doc(alias = "VkBool32")]
562pub type Bool32 = u32;
563#[doc(alias = "VkFlags")]
565pub type Flags = u32;
566#[doc(alias = "VkDeviceSize")]
568pub type DeviceSize = u64;
569#[doc(alias = "VkDeviceAddress")]
571pub type DeviceAddress = u64;
572crate::dispatchable_handle!(
573 Instance, INSTANCE,
574 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstance.html) · Dispatchable Handle",
575 "VkInstance"
576);
577crate::dispatchable_handle!(
578 PhysicalDevice, PHYSICAL_DEVICE,
579 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice.html) · Dispatchable Handle",
580 "VkPhysicalDevice"
581);
582crate::dispatchable_handle!(
583 Device, DEVICE,
584 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevice.html) · Dispatchable Handle",
585 "VkDevice"
586);
587crate::dispatchable_handle!(
588 Queue, QUEUE,
589 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueue.html) · Dispatchable Handle",
590 "VkQueue"
591);
592crate::dispatchable_handle!(
593 CommandBuffer, COMMAND_BUFFER,
594 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBuffer.html) · Dispatchable Handle",
595 "VkCommandBuffer"
596);
597crate::non_dispatchable_handle!(
598 DeviceMemory, DEVICE_MEMORY,
599 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemory.html) · Non-dispatchable Handle",
600 "VkDeviceMemory"
601);
602crate::non_dispatchable_handle!(
603 CommandPool, COMMAND_POOL,
604 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPool.html) · Non-dispatchable Handle",
605 "VkCommandPool"
606);
607crate::non_dispatchable_handle!(
608 Buffer, BUFFER,
609 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuffer.html) · Non-dispatchable Handle",
610 "VkBuffer"
611);
612crate::non_dispatchable_handle!(
613 BufferView, BUFFER_VIEW,
614 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferView.html) · Non-dispatchable Handle",
615 "VkBufferView"
616);
617crate::non_dispatchable_handle!(
618 Image, IMAGE,
619 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImage.html) · Non-dispatchable Handle",
620 "VkImage"
621);
622crate::non_dispatchable_handle!(
623 ImageView, IMAGE_VIEW,
624 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageView.html) · Non-dispatchable Handle",
625 "VkImageView"
626);
627crate::non_dispatchable_handle!(
628 ShaderModule, SHADER_MODULE,
629 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModule.html) · Non-dispatchable Handle",
630 "VkShaderModule"
631);
632crate::non_dispatchable_handle!(
633 Pipeline, PIPELINE,
634 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipeline.html) · Non-dispatchable Handle",
635 "VkPipeline"
636);
637crate::non_dispatchable_handle!(
638 PipelineLayout, PIPELINE_LAYOUT,
639 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayout.html) · Non-dispatchable Handle",
640 "VkPipelineLayout"
641);
642crate::non_dispatchable_handle!(
643 Sampler, SAMPLER,
644 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampler.html) · Non-dispatchable Handle",
645 "VkSampler"
646);
647crate::non_dispatchable_handle!(
648 DescriptorSet, DESCRIPTOR_SET,
649 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSet.html) · Non-dispatchable Handle",
650 "VkDescriptorSet"
651);
652crate::non_dispatchable_handle!(
653 DescriptorSetLayout, DESCRIPTOR_SET_LAYOUT,
654 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayout.html) · Non-dispatchable Handle",
655 "VkDescriptorSetLayout"
656);
657crate::non_dispatchable_handle!(
658 DescriptorPool, DESCRIPTOR_POOL,
659 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPool.html) · Non-dispatchable Handle",
660 "VkDescriptorPool"
661);
662crate::non_dispatchable_handle!(
663 Fence, FENCE,
664 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFence.html) · Non-dispatchable Handle",
665 "VkFence"
666);
667crate::non_dispatchable_handle!(
668 Semaphore, SEMAPHORE,
669 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphore.html) · Non-dispatchable Handle",
670 "VkSemaphore"
671);
672crate::non_dispatchable_handle!(
673 Event, EVENT,
674 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEvent.html) · Non-dispatchable Handle",
675 "VkEvent"
676);
677crate::non_dispatchable_handle!(
678 QueryPool, QUERY_POOL,
679 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPool.html) · Non-dispatchable Handle",
680 "VkQueryPool"
681);
682crate::non_dispatchable_handle!(
683 Framebuffer, FRAMEBUFFER,
684 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebuffer.html) · Non-dispatchable Handle",
685 "VkFramebuffer"
686);
687crate::non_dispatchable_handle!(
688 RenderPass, RENDER_PASS,
689 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPass.html) · Non-dispatchable Handle",
690 "VkRenderPass"
691);
692crate::non_dispatchable_handle!(
693 PipelineCache, PIPELINE_CACHE,
694 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCache.html) · Non-dispatchable Handle",
695 "VkPipelineCache"
696);
697bitflags::bitflags! {
698 #[doc =
699 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateFlags.html) · Bitmask of [`QueryPoolCreateFlagBits`]"]
700 #[doc(alias = "VkQueryPoolCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
701 struct QueryPoolCreateFlags : u32 { #[cfg(empty_bitflag_workaround)] const
702 EMPTY_BITFLAG_WORKAROUND = 0; }
703}
704#[doc(alias = "VkQueryPoolCreateFlagBits")]
706#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
707#[repr(transparent)]
708pub struct QueryPoolCreateFlagBits(pub u32);
709impl QueryPoolCreateFlagBits {
710 #[inline]
711 pub const fn bitmask(&self) -> QueryPoolCreateFlags {
713 QueryPoolCreateFlags::from_bits_truncate(self.0)
714 }
715}
716impl std::fmt::Debug for QueryPoolCreateFlagBits {
717 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
718 f.write_str(
719 match self {
720 _ => "(unknown variant)",
721 },
722 )
723 }
724}
725bitflags::bitflags! {
726 #[doc =
727 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateFlags.html) · Bitmask of [`PipelineDynamicStateCreateFlagBits`]"]
728 #[doc(alias = "VkPipelineDynamicStateCreateFlags")] #[derive(Default)]
729 #[repr(transparent)] pub struct PipelineDynamicStateCreateFlags : u32 {
730 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
731}
732#[doc(alias = "VkPipelineDynamicStateCreateFlagBits")]
734#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
735#[repr(transparent)]
736pub struct PipelineDynamicStateCreateFlagBits(pub u32);
737impl PipelineDynamicStateCreateFlagBits {
738 #[inline]
739 pub const fn bitmask(&self) -> PipelineDynamicStateCreateFlags {
741 PipelineDynamicStateCreateFlags::from_bits_truncate(self.0)
742 }
743}
744impl std::fmt::Debug for PipelineDynamicStateCreateFlagBits {
745 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
746 f.write_str(
747 match self {
748 _ => "(unknown variant)",
749 },
750 )
751 }
752}
753bitflags::bitflags! {
754 #[doc =
755 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html) · Bitmask of [`PipelineMultisampleStateCreateFlagBits`]"]
756 #[doc(alias = "VkPipelineMultisampleStateCreateFlags")] #[derive(Default)]
757 #[repr(transparent)] pub struct PipelineMultisampleStateCreateFlags : u32 {
758 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
759}
760#[doc(alias = "VkPipelineMultisampleStateCreateFlagBits")]
762#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
763#[repr(transparent)]
764pub struct PipelineMultisampleStateCreateFlagBits(pub u32);
765impl PipelineMultisampleStateCreateFlagBits {
766 #[inline]
767 pub const fn bitmask(&self) -> PipelineMultisampleStateCreateFlags {
769 PipelineMultisampleStateCreateFlags::from_bits_truncate(self.0)
770 }
771}
772impl std::fmt::Debug for PipelineMultisampleStateCreateFlagBits {
773 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
774 f.write_str(
775 match self {
776 _ => "(unknown variant)",
777 },
778 )
779 }
780}
781bitflags::bitflags! {
782 #[doc =
783 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html) · Bitmask of [`PipelineRasterizationStateCreateFlagBits`]"]
784 #[doc(alias = "VkPipelineRasterizationStateCreateFlags")] #[derive(Default)]
785 #[repr(transparent)] pub struct PipelineRasterizationStateCreateFlags : u32 {
786 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
787}
788#[doc(alias = "VkPipelineRasterizationStateCreateFlagBits")]
790#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
791#[repr(transparent)]
792pub struct PipelineRasterizationStateCreateFlagBits(pub u32);
793impl PipelineRasterizationStateCreateFlagBits {
794 #[inline]
795 pub const fn bitmask(&self) -> PipelineRasterizationStateCreateFlags {
797 PipelineRasterizationStateCreateFlags::from_bits_truncate(self.0)
798 }
799}
800impl std::fmt::Debug for PipelineRasterizationStateCreateFlagBits {
801 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
802 f.write_str(
803 match self {
804 _ => "(unknown variant)",
805 },
806 )
807 }
808}
809bitflags::bitflags! {
810 #[doc =
811 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateFlags.html) · Bitmask of [`PipelineViewportStateCreateFlagBits`]"]
812 #[doc(alias = "VkPipelineViewportStateCreateFlags")] #[derive(Default)]
813 #[repr(transparent)] pub struct PipelineViewportStateCreateFlags : u32 {
814 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
815}
816#[doc(alias = "VkPipelineViewportStateCreateFlagBits")]
818#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
819#[repr(transparent)]
820pub struct PipelineViewportStateCreateFlagBits(pub u32);
821impl PipelineViewportStateCreateFlagBits {
822 #[inline]
823 pub const fn bitmask(&self) -> PipelineViewportStateCreateFlags {
825 PipelineViewportStateCreateFlags::from_bits_truncate(self.0)
826 }
827}
828impl std::fmt::Debug for PipelineViewportStateCreateFlagBits {
829 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
830 f.write_str(
831 match self {
832 _ => "(unknown variant)",
833 },
834 )
835 }
836}
837bitflags::bitflags! {
838 #[doc =
839 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateFlags.html) · Bitmask of [`PipelineTessellationStateCreateFlagBits`]"]
840 #[doc(alias = "VkPipelineTessellationStateCreateFlags")] #[derive(Default)]
841 #[repr(transparent)] pub struct PipelineTessellationStateCreateFlags : u32 {
842 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
843}
844#[doc(alias = "VkPipelineTessellationStateCreateFlagBits")]
846#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
847#[repr(transparent)]
848pub struct PipelineTessellationStateCreateFlagBits(pub u32);
849impl PipelineTessellationStateCreateFlagBits {
850 #[inline]
851 pub const fn bitmask(&self) -> PipelineTessellationStateCreateFlags {
853 PipelineTessellationStateCreateFlags::from_bits_truncate(self.0)
854 }
855}
856impl std::fmt::Debug for PipelineTessellationStateCreateFlagBits {
857 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
858 f.write_str(
859 match self {
860 _ => "(unknown variant)",
861 },
862 )
863 }
864}
865bitflags::bitflags! {
866 #[doc =
867 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html) · Bitmask of [`PipelineInputAssemblyStateCreateFlagBits`]"]
868 #[doc(alias = "VkPipelineInputAssemblyStateCreateFlags")] #[derive(Default)]
869 #[repr(transparent)] pub struct PipelineInputAssemblyStateCreateFlags : u32 {
870 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
871}
872#[doc(alias = "VkPipelineInputAssemblyStateCreateFlagBits")]
874#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
875#[repr(transparent)]
876pub struct PipelineInputAssemblyStateCreateFlagBits(pub u32);
877impl PipelineInputAssemblyStateCreateFlagBits {
878 #[inline]
879 pub const fn bitmask(&self) -> PipelineInputAssemblyStateCreateFlags {
881 PipelineInputAssemblyStateCreateFlags::from_bits_truncate(self.0)
882 }
883}
884impl std::fmt::Debug for PipelineInputAssemblyStateCreateFlagBits {
885 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
886 f.write_str(
887 match self {
888 _ => "(unknown variant)",
889 },
890 )
891 }
892}
893bitflags::bitflags! {
894 #[doc =
895 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html) · Bitmask of [`PipelineVertexInputStateCreateFlagBits`]"]
896 #[doc(alias = "VkPipelineVertexInputStateCreateFlags")] #[derive(Default)]
897 #[repr(transparent)] pub struct PipelineVertexInputStateCreateFlags : u32 {
898 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
899}
900#[doc(alias = "VkPipelineVertexInputStateCreateFlagBits")]
902#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
903#[repr(transparent)]
904pub struct PipelineVertexInputStateCreateFlagBits(pub u32);
905impl PipelineVertexInputStateCreateFlagBits {
906 #[inline]
907 pub const fn bitmask(&self) -> PipelineVertexInputStateCreateFlags {
909 PipelineVertexInputStateCreateFlags::from_bits_truncate(self.0)
910 }
911}
912impl std::fmt::Debug for PipelineVertexInputStateCreateFlagBits {
913 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
914 f.write_str(
915 match self {
916 _ => "(unknown variant)",
917 },
918 )
919 }
920}
921bitflags::bitflags! {
922 #[doc =
923 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateFlags.html) · Bitmask of [`BufferViewCreateFlagBits`]"]
924 #[doc(alias = "VkBufferViewCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
925 struct BufferViewCreateFlags : u32 { #[cfg(empty_bitflag_workaround)] const
926 EMPTY_BITFLAG_WORKAROUND = 0; }
927}
928#[doc(alias = "VkBufferViewCreateFlagBits")]
930#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
931#[repr(transparent)]
932pub struct BufferViewCreateFlagBits(pub u32);
933impl BufferViewCreateFlagBits {
934 #[inline]
935 pub const fn bitmask(&self) -> BufferViewCreateFlags {
937 BufferViewCreateFlags::from_bits_truncate(self.0)
938 }
939}
940impl std::fmt::Debug for BufferViewCreateFlagBits {
941 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
942 f.write_str(
943 match self {
944 _ => "(unknown variant)",
945 },
946 )
947 }
948}
949bitflags::bitflags! {
950 #[doc =
951 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateFlags.html) · Bitmask of [`DeviceCreateFlagBits`]"]
952 #[doc(alias = "VkDeviceCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
953 struct DeviceCreateFlags : u32 { #[cfg(empty_bitflag_workaround)] const
954 EMPTY_BITFLAG_WORKAROUND = 0; }
955}
956#[doc(alias = "VkDeviceCreateFlagBits")]
958#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
959#[repr(transparent)]
960pub struct DeviceCreateFlagBits(pub u32);
961impl DeviceCreateFlagBits {
962 #[inline]
963 pub const fn bitmask(&self) -> DeviceCreateFlags {
965 DeviceCreateFlags::from_bits_truncate(self.0)
966 }
967}
968impl std::fmt::Debug for DeviceCreateFlagBits {
969 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
970 f.write_str(
971 match self {
972 _ => "(unknown variant)",
973 },
974 )
975 }
976}
977bitflags::bitflags! {
978 #[doc =
979 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateFlags.html) · Bitmask of [`SemaphoreCreateFlagBits`]"]
980 #[doc(alias = "VkSemaphoreCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
981 struct SemaphoreCreateFlags : u32 { #[cfg(empty_bitflag_workaround)] const
982 EMPTY_BITFLAG_WORKAROUND = 0; }
983}
984#[doc(alias = "VkSemaphoreCreateFlagBits")]
986#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
987#[repr(transparent)]
988pub struct SemaphoreCreateFlagBits(pub u32);
989impl SemaphoreCreateFlagBits {
990 #[inline]
991 pub const fn bitmask(&self) -> SemaphoreCreateFlags {
993 SemaphoreCreateFlags::from_bits_truncate(self.0)
994 }
995}
996impl std::fmt::Debug for SemaphoreCreateFlagBits {
997 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
998 f.write_str(
999 match self {
1000 _ => "(unknown variant)",
1001 },
1002 )
1003 }
1004}
1005bitflags::bitflags! {
1006 #[doc =
1007 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateFlags.html) · Bitmask of [`ShaderModuleCreateFlagBits`]"]
1008 #[doc(alias = "VkShaderModuleCreateFlags")] #[derive(Default)] #[repr(transparent)]
1009 pub struct ShaderModuleCreateFlags : u32 { #[cfg(empty_bitflag_workaround)] const
1010 EMPTY_BITFLAG_WORKAROUND = 0; }
1011}
1012#[doc(alias = "VkShaderModuleCreateFlagBits")]
1014#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1015#[repr(transparent)]
1016pub struct ShaderModuleCreateFlagBits(pub u32);
1017impl ShaderModuleCreateFlagBits {
1018 #[inline]
1019 pub const fn bitmask(&self) -> ShaderModuleCreateFlags {
1021 ShaderModuleCreateFlags::from_bits_truncate(self.0)
1022 }
1023}
1024impl std::fmt::Debug for ShaderModuleCreateFlagBits {
1025 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1026 f.write_str(
1027 match self {
1028 _ => "(unknown variant)",
1029 },
1030 )
1031 }
1032}
1033bitflags::bitflags! {
1034 #[doc =
1035 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapFlags.html) · Bitmask of [`MemoryMapFlagBits`]"]
1036 #[doc(alias = "VkMemoryMapFlags")] #[derive(Default)] #[repr(transparent)] pub struct
1037 MemoryMapFlags : u32 { #[cfg(empty_bitflag_workaround)] const
1038 EMPTY_BITFLAG_WORKAROUND = 0; }
1039}
1040#[doc(alias = "VkMemoryMapFlagBits")]
1042#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1043#[repr(transparent)]
1044pub struct MemoryMapFlagBits(pub u32);
1045impl MemoryMapFlagBits {
1046 #[inline]
1047 pub const fn bitmask(&self) -> MemoryMapFlags {
1049 MemoryMapFlags::from_bits_truncate(self.0)
1050 }
1051}
1052impl std::fmt::Debug for MemoryMapFlagBits {
1053 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1054 f.write_str(
1055 match self {
1056 _ => "(unknown variant)",
1057 },
1058 )
1059 }
1060}
1061bitflags::bitflags! {
1062 #[doc =
1063 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolResetFlags.html) · Bitmask of [`DescriptorPoolResetFlagBits`]"]
1064 #[doc(alias = "VkDescriptorPoolResetFlags")] #[derive(Default)] #[repr(transparent)]
1065 pub struct DescriptorPoolResetFlags : u32 { #[cfg(empty_bitflag_workaround)] const
1066 EMPTY_BITFLAG_WORKAROUND = 0; }
1067}
1068#[doc(alias = "VkDescriptorPoolResetFlagBits")]
1070#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1071#[repr(transparent)]
1072pub struct DescriptorPoolResetFlagBits(pub u32);
1073impl DescriptorPoolResetFlagBits {
1074 #[inline]
1075 pub const fn bitmask(&self) -> DescriptorPoolResetFlags {
1077 DescriptorPoolResetFlags::from_bits_truncate(self.0)
1078 }
1079}
1080impl std::fmt::Debug for DescriptorPoolResetFlagBits {
1081 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1082 f.write_str(
1083 match self {
1084 _ => "(unknown variant)",
1085 },
1086 )
1087 }
1088}
1089#[doc(alias = "VkAttachmentLoadOp")]
1091#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1092#[repr(transparent)]
1093pub struct AttachmentLoadOp(pub i32);
1094impl std::fmt::Debug for AttachmentLoadOp {
1095 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1096 f.write_str(
1097 match self {
1098 &Self::LOAD => "LOAD",
1099 &Self::CLEAR => "CLEAR",
1100 &Self::DONT_CARE => "DONT_CARE",
1101 &Self::NONE_EXT => "NONE_EXT",
1102 _ => "(unknown variant)",
1103 },
1104 )
1105 }
1106}
1107impl crate::vk1_0::AttachmentLoadOp {
1109 pub const LOAD: Self = Self(0);
1110 pub const CLEAR: Self = Self(1);
1111 pub const DONT_CARE: Self = Self(2);
1112}
1113#[doc(alias = "VkAttachmentStoreOp")]
1115#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1116#[repr(transparent)]
1117pub struct AttachmentStoreOp(pub i32);
1118impl std::fmt::Debug for AttachmentStoreOp {
1119 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1120 f.write_str(
1121 match self {
1122 &Self::STORE => "STORE",
1123 &Self::DONT_CARE => "DONT_CARE",
1124 &Self::NONE => "NONE",
1125 _ => "(unknown variant)",
1126 },
1127 )
1128 }
1129}
1130impl crate::vk1_0::AttachmentStoreOp {
1132 pub const STORE: Self = Self(0);
1133 pub const DONT_CARE: Self = Self(1);
1134}
1135#[doc(alias = "VkBlendFactor")]
1137#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1138#[repr(transparent)]
1139pub struct BlendFactor(pub i32);
1140impl std::fmt::Debug for BlendFactor {
1141 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1142 f.write_str(
1143 match self {
1144 &Self::ZERO => "ZERO",
1145 &Self::ONE => "ONE",
1146 &Self::SRC_COLOR => "SRC_COLOR",
1147 &Self::ONE_MINUS_SRC_COLOR => "ONE_MINUS_SRC_COLOR",
1148 &Self::DST_COLOR => "DST_COLOR",
1149 &Self::ONE_MINUS_DST_COLOR => "ONE_MINUS_DST_COLOR",
1150 &Self::SRC_ALPHA => "SRC_ALPHA",
1151 &Self::ONE_MINUS_SRC_ALPHA => "ONE_MINUS_SRC_ALPHA",
1152 &Self::DST_ALPHA => "DST_ALPHA",
1153 &Self::ONE_MINUS_DST_ALPHA => "ONE_MINUS_DST_ALPHA",
1154 &Self::CONSTANT_COLOR => "CONSTANT_COLOR",
1155 &Self::ONE_MINUS_CONSTANT_COLOR => "ONE_MINUS_CONSTANT_COLOR",
1156 &Self::CONSTANT_ALPHA => "CONSTANT_ALPHA",
1157 &Self::ONE_MINUS_CONSTANT_ALPHA => "ONE_MINUS_CONSTANT_ALPHA",
1158 &Self::SRC_ALPHA_SATURATE => "SRC_ALPHA_SATURATE",
1159 &Self::SRC1_COLOR => "SRC1_COLOR",
1160 &Self::ONE_MINUS_SRC1_COLOR => "ONE_MINUS_SRC1_COLOR",
1161 &Self::SRC1_ALPHA => "SRC1_ALPHA",
1162 &Self::ONE_MINUS_SRC1_ALPHA => "ONE_MINUS_SRC1_ALPHA",
1163 _ => "(unknown variant)",
1164 },
1165 )
1166 }
1167}
1168impl crate::vk1_0::BlendFactor {
1170 pub const ZERO: Self = Self(0);
1171 pub const ONE: Self = Self(1);
1172 pub const SRC_COLOR: Self = Self(2);
1173 pub const ONE_MINUS_SRC_COLOR: Self = Self(3);
1174 pub const DST_COLOR: Self = Self(4);
1175 pub const ONE_MINUS_DST_COLOR: Self = Self(5);
1176 pub const SRC_ALPHA: Self = Self(6);
1177 pub const ONE_MINUS_SRC_ALPHA: Self = Self(7);
1178 pub const DST_ALPHA: Self = Self(8);
1179 pub const ONE_MINUS_DST_ALPHA: Self = Self(9);
1180 pub const CONSTANT_COLOR: Self = Self(10);
1181 pub const ONE_MINUS_CONSTANT_COLOR: Self = Self(11);
1182 pub const CONSTANT_ALPHA: Self = Self(12);
1183 pub const ONE_MINUS_CONSTANT_ALPHA: Self = Self(13);
1184 pub const SRC_ALPHA_SATURATE: Self = Self(14);
1185 pub const SRC1_COLOR: Self = Self(15);
1186 pub const ONE_MINUS_SRC1_COLOR: Self = Self(16);
1187 pub const SRC1_ALPHA: Self = Self(17);
1188 pub const ONE_MINUS_SRC1_ALPHA: Self = Self(18);
1189}
1190#[doc(alias = "VkBlendOp")]
1192#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1193#[repr(transparent)]
1194pub struct BlendOp(pub i32);
1195impl std::fmt::Debug for BlendOp {
1196 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1197 f.write_str(
1198 match self {
1199 &Self::ADD => "ADD",
1200 &Self::SUBTRACT => "SUBTRACT",
1201 &Self::REVERSE_SUBTRACT => "REVERSE_SUBTRACT",
1202 &Self::MIN => "MIN",
1203 &Self::MAX => "MAX",
1204 &Self::ZERO_EXT => "ZERO_EXT",
1205 &Self::SRC_EXT => "SRC_EXT",
1206 &Self::DST_EXT => "DST_EXT",
1207 &Self::SRC_OVER_EXT => "SRC_OVER_EXT",
1208 &Self::DST_OVER_EXT => "DST_OVER_EXT",
1209 &Self::SRC_IN_EXT => "SRC_IN_EXT",
1210 &Self::DST_IN_EXT => "DST_IN_EXT",
1211 &Self::SRC_OUT_EXT => "SRC_OUT_EXT",
1212 &Self::DST_OUT_EXT => "DST_OUT_EXT",
1213 &Self::SRC_ATOP_EXT => "SRC_ATOP_EXT",
1214 &Self::DST_ATOP_EXT => "DST_ATOP_EXT",
1215 &Self::XOR_EXT => "XOR_EXT",
1216 &Self::MULTIPLY_EXT => "MULTIPLY_EXT",
1217 &Self::SCREEN_EXT => "SCREEN_EXT",
1218 &Self::OVERLAY_EXT => "OVERLAY_EXT",
1219 &Self::DARKEN_EXT => "DARKEN_EXT",
1220 &Self::LIGHTEN_EXT => "LIGHTEN_EXT",
1221 &Self::COLORDODGE_EXT => "COLORDODGE_EXT",
1222 &Self::COLORBURN_EXT => "COLORBURN_EXT",
1223 &Self::HARDLIGHT_EXT => "HARDLIGHT_EXT",
1224 &Self::SOFTLIGHT_EXT => "SOFTLIGHT_EXT",
1225 &Self::DIFFERENCE_EXT => "DIFFERENCE_EXT",
1226 &Self::EXCLUSION_EXT => "EXCLUSION_EXT",
1227 &Self::INVERT_EXT => "INVERT_EXT",
1228 &Self::INVERT_RGB_EXT => "INVERT_RGB_EXT",
1229 &Self::LINEARDODGE_EXT => "LINEARDODGE_EXT",
1230 &Self::LINEARBURN_EXT => "LINEARBURN_EXT",
1231 &Self::VIVIDLIGHT_EXT => "VIVIDLIGHT_EXT",
1232 &Self::LINEARLIGHT_EXT => "LINEARLIGHT_EXT",
1233 &Self::PINLIGHT_EXT => "PINLIGHT_EXT",
1234 &Self::HARDMIX_EXT => "HARDMIX_EXT",
1235 &Self::HSL_HUE_EXT => "HSL_HUE_EXT",
1236 &Self::HSL_SATURATION_EXT => "HSL_SATURATION_EXT",
1237 &Self::HSL_COLOR_EXT => "HSL_COLOR_EXT",
1238 &Self::HSL_LUMINOSITY_EXT => "HSL_LUMINOSITY_EXT",
1239 &Self::PLUS_EXT => "PLUS_EXT",
1240 &Self::PLUS_CLAMPED_EXT => "PLUS_CLAMPED_EXT",
1241 &Self::PLUS_CLAMPED_ALPHA_EXT => "PLUS_CLAMPED_ALPHA_EXT",
1242 &Self::PLUS_DARKER_EXT => "PLUS_DARKER_EXT",
1243 &Self::MINUS_EXT => "MINUS_EXT",
1244 &Self::MINUS_CLAMPED_EXT => "MINUS_CLAMPED_EXT",
1245 &Self::CONTRAST_EXT => "CONTRAST_EXT",
1246 &Self::INVERT_OVG_EXT => "INVERT_OVG_EXT",
1247 &Self::RED_EXT => "RED_EXT",
1248 &Self::GREEN_EXT => "GREEN_EXT",
1249 &Self::BLUE_EXT => "BLUE_EXT",
1250 _ => "(unknown variant)",
1251 },
1252 )
1253 }
1254}
1255impl crate::vk1_0::BlendOp {
1257 pub const ADD: Self = Self(0);
1258 pub const SUBTRACT: Self = Self(1);
1259 pub const REVERSE_SUBTRACT: Self = Self(2);
1260 pub const MIN: Self = Self(3);
1261 pub const MAX: Self = Self(4);
1262}
1263#[doc(alias = "VkBorderColor")]
1265#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1266#[repr(transparent)]
1267pub struct BorderColor(pub i32);
1268impl std::fmt::Debug for BorderColor {
1269 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1270 f.write_str(
1271 match self {
1272 &Self::FLOAT_TRANSPARENT_BLACK => "FLOAT_TRANSPARENT_BLACK",
1273 &Self::INT_TRANSPARENT_BLACK => "INT_TRANSPARENT_BLACK",
1274 &Self::FLOAT_OPAQUE_BLACK => "FLOAT_OPAQUE_BLACK",
1275 &Self::INT_OPAQUE_BLACK => "INT_OPAQUE_BLACK",
1276 &Self::FLOAT_OPAQUE_WHITE => "FLOAT_OPAQUE_WHITE",
1277 &Self::INT_OPAQUE_WHITE => "INT_OPAQUE_WHITE",
1278 &Self::FLOAT_CUSTOM_EXT => "FLOAT_CUSTOM_EXT",
1279 &Self::INT_CUSTOM_EXT => "INT_CUSTOM_EXT",
1280 _ => "(unknown variant)",
1281 },
1282 )
1283 }
1284}
1285impl crate::vk1_0::BorderColor {
1287 pub const FLOAT_TRANSPARENT_BLACK: Self = Self(0);
1288 pub const INT_TRANSPARENT_BLACK: Self = Self(1);
1289 pub const FLOAT_OPAQUE_BLACK: Self = Self(2);
1290 pub const INT_OPAQUE_BLACK: Self = Self(3);
1291 pub const FLOAT_OPAQUE_WHITE: Self = Self(4);
1292 pub const INT_OPAQUE_WHITE: Self = Self(5);
1293}
1294bitflags::bitflags! {
1295 #[doc =
1296 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateFlags.html) · Bitmask of [`FramebufferCreateFlagBits`]"]
1297 #[doc(alias = "VkFramebufferCreateFlags")] #[derive(Default)] #[repr(transparent)]
1298 pub struct FramebufferCreateFlags : u32 { const IMAGELESS =
1299 FramebufferCreateFlagBits::IMAGELESS.0; const IMAGELESS_KHR =
1300 FramebufferCreateFlagBits::IMAGELESS_KHR.0; }
1301}
1302#[doc(alias = "VkFramebufferCreateFlagBits")]
1304#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1305#[repr(transparent)]
1306pub struct FramebufferCreateFlagBits(pub u32);
1307impl FramebufferCreateFlagBits {
1308 #[inline]
1309 pub const fn bitmask(&self) -> FramebufferCreateFlags {
1311 FramebufferCreateFlags::from_bits_truncate(self.0)
1312 }
1313}
1314impl std::fmt::Debug for FramebufferCreateFlagBits {
1315 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1316 f.write_str(
1317 match self {
1318 &Self::IMAGELESS => "IMAGELESS",
1319 _ => "(unknown variant)",
1320 },
1321 )
1322 }
1323}
1324bitflags::bitflags! {
1325 #[doc =
1326 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateFlags.html) · Bitmask of [`RenderPassCreateFlagBits`]"]
1327 #[doc(alias = "VkRenderPassCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
1328 struct RenderPassCreateFlags : u32 { const TRANSFORM_QCOM =
1329 RenderPassCreateFlagBits::TRANSFORM_QCOM.0; }
1330}
1331#[doc(alias = "VkRenderPassCreateFlagBits")]
1333#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1334#[repr(transparent)]
1335pub struct RenderPassCreateFlagBits(pub u32);
1336impl RenderPassCreateFlagBits {
1337 #[inline]
1338 pub const fn bitmask(&self) -> RenderPassCreateFlags {
1340 RenderPassCreateFlags::from_bits_truncate(self.0)
1341 }
1342}
1343impl std::fmt::Debug for RenderPassCreateFlagBits {
1344 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1345 f.write_str(
1346 match self {
1347 &Self::TRANSFORM_QCOM => "TRANSFORM_QCOM",
1348 _ => "(unknown variant)",
1349 },
1350 )
1351 }
1352}
1353bitflags::bitflags! {
1354 #[doc =
1355 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateFlags.html) · Bitmask of [`SamplerCreateFlagBits`]"]
1356 #[doc(alias = "VkSamplerCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
1357 struct SamplerCreateFlags : u32 { const SUBSAMPLED_EXT =
1358 SamplerCreateFlagBits::SUBSAMPLED_EXT.0; const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT =
1359 SamplerCreateFlagBits::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0; }
1360}
1361#[doc(alias = "VkSamplerCreateFlagBits")]
1363#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1364#[repr(transparent)]
1365pub struct SamplerCreateFlagBits(pub u32);
1366impl SamplerCreateFlagBits {
1367 #[inline]
1368 pub const fn bitmask(&self) -> SamplerCreateFlags {
1370 SamplerCreateFlags::from_bits_truncate(self.0)
1371 }
1372}
1373impl std::fmt::Debug for SamplerCreateFlagBits {
1374 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1375 f.write_str(
1376 match self {
1377 &Self::SUBSAMPLED_EXT => "SUBSAMPLED_EXT",
1378 &Self::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT => {
1379 "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT"
1380 }
1381 _ => "(unknown variant)",
1382 },
1383 )
1384 }
1385}
1386#[doc(alias = "VkPipelineCacheHeaderVersion")]
1388#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1389#[repr(transparent)]
1390pub struct PipelineCacheHeaderVersion(pub i32);
1391impl std::fmt::Debug for PipelineCacheHeaderVersion {
1392 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1393 f.write_str(
1394 match self {
1395 &Self::ONE => "ONE",
1396 _ => "(unknown variant)",
1397 },
1398 )
1399 }
1400}
1401impl crate::vk1_0::PipelineCacheHeaderVersion {
1403 pub const ONE: Self = Self(1);
1404}
1405bitflags::bitflags! {
1406 #[doc =
1407 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheCreateFlags.html) · Bitmask of [`PipelineCacheCreateFlagBits`]"]
1408 #[doc(alias = "VkPipelineCacheCreateFlags")] #[derive(Default)] #[repr(transparent)]
1409 pub struct PipelineCacheCreateFlags : u32 { const EXTERNALLY_SYNCHRONIZED =
1410 PipelineCacheCreateFlagBits::EXTERNALLY_SYNCHRONIZED.0; const
1411 EXTERNALLY_SYNCHRONIZED_EXT =
1412 PipelineCacheCreateFlagBits::EXTERNALLY_SYNCHRONIZED_EXT.0; }
1413}
1414#[doc(alias = "VkPipelineCacheCreateFlagBits")]
1416#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1417#[repr(transparent)]
1418pub struct PipelineCacheCreateFlagBits(pub u32);
1419impl PipelineCacheCreateFlagBits {
1420 #[inline]
1421 pub const fn bitmask(&self) -> PipelineCacheCreateFlags {
1423 PipelineCacheCreateFlags::from_bits_truncate(self.0)
1424 }
1425}
1426impl std::fmt::Debug for PipelineCacheCreateFlagBits {
1427 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1428 f.write_str(
1429 match self {
1430 &Self::EXTERNALLY_SYNCHRONIZED => "EXTERNALLY_SYNCHRONIZED",
1431 _ => "(unknown variant)",
1432 },
1433 )
1434 }
1435}
1436bitflags::bitflags! {
1437 #[doc =
1438 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateFlags.html) · Bitmask of [`PipelineShaderStageCreateFlagBits`]"]
1439 #[doc(alias = "VkPipelineShaderStageCreateFlags")] #[derive(Default)]
1440 #[repr(transparent)] pub struct PipelineShaderStageCreateFlags : u32 { const
1441 ALLOW_VARYING_SUBGROUP_SIZE =
1442 PipelineShaderStageCreateFlagBits::ALLOW_VARYING_SUBGROUP_SIZE.0; const
1443 REQUIRE_FULL_SUBGROUPS = PipelineShaderStageCreateFlagBits::REQUIRE_FULL_SUBGROUPS.0;
1444 const ALLOW_VARYING_SUBGROUP_SIZE_EXT =
1445 PipelineShaderStageCreateFlagBits::ALLOW_VARYING_SUBGROUP_SIZE_EXT.0; const
1446 REQUIRE_FULL_SUBGROUPS_EXT =
1447 PipelineShaderStageCreateFlagBits::REQUIRE_FULL_SUBGROUPS_EXT.0; }
1448}
1449#[doc(alias = "VkPipelineShaderStageCreateFlagBits")]
1451#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1452#[repr(transparent)]
1453pub struct PipelineShaderStageCreateFlagBits(pub u32);
1454impl PipelineShaderStageCreateFlagBits {
1455 #[inline]
1456 pub const fn bitmask(&self) -> PipelineShaderStageCreateFlags {
1458 PipelineShaderStageCreateFlags::from_bits_truncate(self.0)
1459 }
1460}
1461impl std::fmt::Debug for PipelineShaderStageCreateFlagBits {
1462 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1463 f.write_str(
1464 match self {
1465 &Self::ALLOW_VARYING_SUBGROUP_SIZE => "ALLOW_VARYING_SUBGROUP_SIZE",
1466 &Self::REQUIRE_FULL_SUBGROUPS => "REQUIRE_FULL_SUBGROUPS",
1467 _ => "(unknown variant)",
1468 },
1469 )
1470 }
1471}
1472bitflags::bitflags! {
1473 #[doc =
1474 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateFlags.html) · Bitmask of [`DescriptorSetLayoutCreateFlagBits`]"]
1475 #[doc(alias = "VkDescriptorSetLayoutCreateFlags")] #[derive(Default)]
1476 #[repr(transparent)] pub struct DescriptorSetLayoutCreateFlags : u32 { const
1477 UPDATE_AFTER_BIND_POOL = DescriptorSetLayoutCreateFlagBits::UPDATE_AFTER_BIND_POOL.0;
1478 const PUSH_DESCRIPTOR_KHR = DescriptorSetLayoutCreateFlagBits::PUSH_DESCRIPTOR_KHR.0;
1479 const HOST_ONLY_POOL_VALVE = DescriptorSetLayoutCreateFlagBits::HOST_ONLY_POOL_VALVE
1480 .0; const UPDATE_AFTER_BIND_POOL_EXT =
1481 DescriptorSetLayoutCreateFlagBits::UPDATE_AFTER_BIND_POOL_EXT.0; }
1482}
1483#[doc(alias = "VkDescriptorSetLayoutCreateFlagBits")]
1485#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1486#[repr(transparent)]
1487pub struct DescriptorSetLayoutCreateFlagBits(pub u32);
1488impl DescriptorSetLayoutCreateFlagBits {
1489 #[inline]
1490 pub const fn bitmask(&self) -> DescriptorSetLayoutCreateFlags {
1492 DescriptorSetLayoutCreateFlags::from_bits_truncate(self.0)
1493 }
1494}
1495impl std::fmt::Debug for DescriptorSetLayoutCreateFlagBits {
1496 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1497 f.write_str(
1498 match self {
1499 &Self::UPDATE_AFTER_BIND_POOL => "UPDATE_AFTER_BIND_POOL",
1500 &Self::PUSH_DESCRIPTOR_KHR => "PUSH_DESCRIPTOR_KHR",
1501 &Self::HOST_ONLY_POOL_VALVE => "HOST_ONLY_POOL_VALVE",
1502 _ => "(unknown variant)",
1503 },
1504 )
1505 }
1506}
1507bitflags::bitflags! {
1508 #[doc =
1509 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateFlags.html) · Bitmask of [`InstanceCreateFlagBits`]"]
1510 #[doc(alias = "VkInstanceCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
1511 struct InstanceCreateFlags : u32 { const ENUMERATE_PORTABILITY_KHR =
1512 InstanceCreateFlagBits::ENUMERATE_PORTABILITY_KHR.0; }
1513}
1514#[doc(alias = "VkInstanceCreateFlagBits")]
1516#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1517#[repr(transparent)]
1518pub struct InstanceCreateFlagBits(pub u32);
1519impl InstanceCreateFlagBits {
1520 #[inline]
1521 pub const fn bitmask(&self) -> InstanceCreateFlags {
1523 InstanceCreateFlags::from_bits_truncate(self.0)
1524 }
1525}
1526impl std::fmt::Debug for InstanceCreateFlagBits {
1527 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1528 f.write_str(
1529 match self {
1530 &Self::ENUMERATE_PORTABILITY_KHR => "ENUMERATE_PORTABILITY_KHR",
1531 _ => "(unknown variant)",
1532 },
1533 )
1534 }
1535}
1536bitflags::bitflags! {
1537 #[doc =
1538 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueCreateFlags.html) · Bitmask of [`DeviceQueueCreateFlagBits`]"]
1539 #[doc(alias = "VkDeviceQueueCreateFlags")] #[derive(Default)] #[repr(transparent)]
1540 pub struct DeviceQueueCreateFlags : u32 { const PROTECTED =
1541 DeviceQueueCreateFlagBits::PROTECTED.0; }
1542}
1543#[doc(alias = "VkDeviceQueueCreateFlagBits")]
1545#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1546#[repr(transparent)]
1547pub struct DeviceQueueCreateFlagBits(pub u32);
1548impl DeviceQueueCreateFlagBits {
1549 #[inline]
1550 pub const fn bitmask(&self) -> DeviceQueueCreateFlags {
1552 DeviceQueueCreateFlags::from_bits_truncate(self.0)
1553 }
1554}
1555impl std::fmt::Debug for DeviceQueueCreateFlagBits {
1556 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1557 f.write_str(
1558 match self {
1559 &Self::PROTECTED => "PROTECTED",
1560 _ => "(unknown variant)",
1561 },
1562 )
1563 }
1564}
1565bitflags::bitflags! {
1566 #[doc =
1567 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCreateFlags.html) · Bitmask of [`BufferCreateFlagBits`]"]
1568 #[doc(alias = "VkBufferCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
1569 struct BufferCreateFlags : u32 { const SPARSE_BINDING =
1570 BufferCreateFlagBits::SPARSE_BINDING.0; const SPARSE_RESIDENCY =
1571 BufferCreateFlagBits::SPARSE_RESIDENCY.0; const SPARSE_ALIASED =
1572 BufferCreateFlagBits::SPARSE_ALIASED.0; const PROTECTED =
1573 BufferCreateFlagBits::PROTECTED.0; const DEVICE_ADDRESS_CAPTURE_REPLAY =
1574 BufferCreateFlagBits::DEVICE_ADDRESS_CAPTURE_REPLAY.0; const
1575 DEVICE_ADDRESS_CAPTURE_REPLAY_EXT =
1576 BufferCreateFlagBits::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0; const
1577 DEVICE_ADDRESS_CAPTURE_REPLAY_KHR =
1578 BufferCreateFlagBits::DEVICE_ADDRESS_CAPTURE_REPLAY_KHR.0; }
1579}
1580#[doc(alias = "VkBufferCreateFlagBits")]
1582#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1583#[repr(transparent)]
1584pub struct BufferCreateFlagBits(pub u32);
1585impl BufferCreateFlagBits {
1586 #[inline]
1587 pub const fn bitmask(&self) -> BufferCreateFlags {
1589 BufferCreateFlags::from_bits_truncate(self.0)
1590 }
1591}
1592impl std::fmt::Debug for BufferCreateFlagBits {
1593 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1594 f.write_str(
1595 match self {
1596 &Self::SPARSE_BINDING => "SPARSE_BINDING",
1597 &Self::SPARSE_RESIDENCY => "SPARSE_RESIDENCY",
1598 &Self::SPARSE_ALIASED => "SPARSE_ALIASED",
1599 &Self::PROTECTED => "PROTECTED",
1600 &Self::DEVICE_ADDRESS_CAPTURE_REPLAY => "DEVICE_ADDRESS_CAPTURE_REPLAY",
1601 _ => "(unknown variant)",
1602 },
1603 )
1604 }
1605}
1606impl crate::vk1_0::BufferCreateFlagBits {
1608 pub const SPARSE_BINDING: Self = Self(1);
1609 pub const SPARSE_RESIDENCY: Self = Self(2);
1610 pub const SPARSE_ALIASED: Self = Self(4);
1611}
1612bitflags::bitflags! {
1613 #[doc =
1614 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferUsageFlags.html) · Bitmask of [`BufferUsageFlagBits`]"]
1615 #[doc(alias = "VkBufferUsageFlags")] #[derive(Default)] #[repr(transparent)] pub
1616 struct BufferUsageFlags : u32 { const TRANSFER_SRC =
1617 BufferUsageFlagBits::TRANSFER_SRC.0; const TRANSFER_DST =
1618 BufferUsageFlagBits::TRANSFER_DST.0; const UNIFORM_TEXEL_BUFFER =
1619 BufferUsageFlagBits::UNIFORM_TEXEL_BUFFER.0; const STORAGE_TEXEL_BUFFER =
1620 BufferUsageFlagBits::STORAGE_TEXEL_BUFFER.0; const UNIFORM_BUFFER =
1621 BufferUsageFlagBits::UNIFORM_BUFFER.0; const STORAGE_BUFFER =
1622 BufferUsageFlagBits::STORAGE_BUFFER.0; const INDEX_BUFFER =
1623 BufferUsageFlagBits::INDEX_BUFFER.0; const VERTEX_BUFFER =
1624 BufferUsageFlagBits::VERTEX_BUFFER.0; const INDIRECT_BUFFER =
1625 BufferUsageFlagBits::INDIRECT_BUFFER.0; const SHADER_DEVICE_ADDRESS =
1626 BufferUsageFlagBits::SHADER_DEVICE_ADDRESS.0; const VIDEO_DECODE_SRC_KHR =
1627 BufferUsageFlagBits::VIDEO_DECODE_SRC_KHR.0; const VIDEO_DECODE_DST_KHR =
1628 BufferUsageFlagBits::VIDEO_DECODE_DST_KHR.0; const TRANSFORM_FEEDBACK_BUFFER_EXT =
1629 BufferUsageFlagBits::TRANSFORM_FEEDBACK_BUFFER_EXT.0; const
1630 TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT =
1631 BufferUsageFlagBits::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0; const
1632 CONDITIONAL_RENDERING_EXT = BufferUsageFlagBits::CONDITIONAL_RENDERING_EXT.0; const
1633 ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR =
1634 BufferUsageFlagBits::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0; const
1635 ACCELERATION_STRUCTURE_STORAGE_KHR =
1636 BufferUsageFlagBits::ACCELERATION_STRUCTURE_STORAGE_KHR.0; const
1637 SHADER_BINDING_TABLE_KHR = BufferUsageFlagBits::SHADER_BINDING_TABLE_KHR.0; const
1638 VIDEO_ENCODE_DST_KHR = BufferUsageFlagBits::VIDEO_ENCODE_DST_KHR.0; const
1639 VIDEO_ENCODE_SRC_KHR = BufferUsageFlagBits::VIDEO_ENCODE_SRC_KHR.0; const
1640 RAY_TRACING_NV = BufferUsageFlagBits::RAY_TRACING_NV.0; const
1641 SHADER_DEVICE_ADDRESS_EXT = BufferUsageFlagBits::SHADER_DEVICE_ADDRESS_EXT.0; const
1642 SHADER_DEVICE_ADDRESS_KHR = BufferUsageFlagBits::SHADER_DEVICE_ADDRESS_KHR.0; }
1643}
1644#[doc(alias = "VkBufferUsageFlagBits")]
1646#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1647#[repr(transparent)]
1648pub struct BufferUsageFlagBits(pub u32);
1649impl BufferUsageFlagBits {
1650 #[inline]
1651 pub const fn bitmask(&self) -> BufferUsageFlags {
1653 BufferUsageFlags::from_bits_truncate(self.0)
1654 }
1655}
1656impl std::fmt::Debug for BufferUsageFlagBits {
1657 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1658 f.write_str(
1659 match self {
1660 &Self::TRANSFER_SRC => "TRANSFER_SRC",
1661 &Self::TRANSFER_DST => "TRANSFER_DST",
1662 &Self::UNIFORM_TEXEL_BUFFER => "UNIFORM_TEXEL_BUFFER",
1663 &Self::STORAGE_TEXEL_BUFFER => "STORAGE_TEXEL_BUFFER",
1664 &Self::UNIFORM_BUFFER => "UNIFORM_BUFFER",
1665 &Self::STORAGE_BUFFER => "STORAGE_BUFFER",
1666 &Self::INDEX_BUFFER => "INDEX_BUFFER",
1667 &Self::VERTEX_BUFFER => "VERTEX_BUFFER",
1668 &Self::INDIRECT_BUFFER => "INDIRECT_BUFFER",
1669 &Self::SHADER_DEVICE_ADDRESS => "SHADER_DEVICE_ADDRESS",
1670 &Self::VIDEO_DECODE_SRC_KHR => "VIDEO_DECODE_SRC_KHR",
1671 &Self::VIDEO_DECODE_DST_KHR => "VIDEO_DECODE_DST_KHR",
1672 &Self::TRANSFORM_FEEDBACK_BUFFER_EXT => "TRANSFORM_FEEDBACK_BUFFER_EXT",
1673 &Self::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT => {
1674 "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT"
1675 }
1676 &Self::CONDITIONAL_RENDERING_EXT => "CONDITIONAL_RENDERING_EXT",
1677 &Self::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR => {
1678 "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR"
1679 }
1680 &Self::ACCELERATION_STRUCTURE_STORAGE_KHR => {
1681 "ACCELERATION_STRUCTURE_STORAGE_KHR"
1682 }
1683 &Self::SHADER_BINDING_TABLE_KHR => "SHADER_BINDING_TABLE_KHR",
1684 &Self::VIDEO_ENCODE_DST_KHR => "VIDEO_ENCODE_DST_KHR",
1685 &Self::VIDEO_ENCODE_SRC_KHR => "VIDEO_ENCODE_SRC_KHR",
1686 _ => "(unknown variant)",
1687 },
1688 )
1689 }
1690}
1691impl crate::vk1_0::BufferUsageFlagBits {
1693 pub const TRANSFER_SRC: Self = Self(1);
1694 pub const TRANSFER_DST: Self = Self(2);
1695 pub const UNIFORM_TEXEL_BUFFER: Self = Self(4);
1696 pub const STORAGE_TEXEL_BUFFER: Self = Self(8);
1697 pub const UNIFORM_BUFFER: Self = Self(16);
1698 pub const STORAGE_BUFFER: Self = Self(32);
1699 pub const INDEX_BUFFER: Self = Self(64);
1700 pub const VERTEX_BUFFER: Self = Self(128);
1701 pub const INDIRECT_BUFFER: Self = Self(256);
1702}
1703bitflags::bitflags! {
1704 #[doc =
1705 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorComponentFlags.html) · Bitmask of [`ColorComponentFlagBits`]"]
1706 #[doc(alias = "VkColorComponentFlags")] #[derive(Default)] #[repr(transparent)] pub
1707 struct ColorComponentFlags : u32 { const R = ColorComponentFlagBits::R.0; const G =
1708 ColorComponentFlagBits::G.0; const B = ColorComponentFlagBits::B.0; const A =
1709 ColorComponentFlagBits::A.0; }
1710}
1711#[doc(alias = "VkColorComponentFlagBits")]
1713#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1714#[repr(transparent)]
1715pub struct ColorComponentFlagBits(pub u32);
1716impl ColorComponentFlagBits {
1717 #[inline]
1718 pub const fn bitmask(&self) -> ColorComponentFlags {
1720 ColorComponentFlags::from_bits_truncate(self.0)
1721 }
1722}
1723impl std::fmt::Debug for ColorComponentFlagBits {
1724 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1725 f.write_str(
1726 match self {
1727 &Self::R => "R",
1728 &Self::G => "G",
1729 &Self::B => "B",
1730 &Self::A => "A",
1731 _ => "(unknown variant)",
1732 },
1733 )
1734 }
1735}
1736impl crate::vk1_0::ColorComponentFlagBits {
1738 pub const R: Self = Self(1);
1739 pub const G: Self = Self(2);
1740 pub const B: Self = Self(4);
1741 pub const A: Self = Self(8);
1742}
1743#[doc(alias = "VkComponentSwizzle")]
1745#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1746#[repr(transparent)]
1747pub struct ComponentSwizzle(pub i32);
1748impl std::fmt::Debug for ComponentSwizzle {
1749 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1750 f.write_str(
1751 match self {
1752 &Self::IDENTITY => "IDENTITY",
1753 &Self::ZERO => "ZERO",
1754 &Self::ONE => "ONE",
1755 &Self::R => "R",
1756 &Self::G => "G",
1757 &Self::B => "B",
1758 &Self::A => "A",
1759 _ => "(unknown variant)",
1760 },
1761 )
1762 }
1763}
1764impl crate::vk1_0::ComponentSwizzle {
1766 pub const IDENTITY: Self = Self(0);
1767 pub const ZERO: Self = Self(1);
1768 pub const ONE: Self = Self(2);
1769 pub const R: Self = Self(3);
1770 pub const G: Self = Self(4);
1771 pub const B: Self = Self(5);
1772 pub const A: Self = Self(6);
1773}
1774bitflags::bitflags! {
1775 #[doc =
1776 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateFlags.html) · Bitmask of [`CommandPoolCreateFlagBits`]"]
1777 #[doc(alias = "VkCommandPoolCreateFlags")] #[derive(Default)] #[repr(transparent)]
1778 pub struct CommandPoolCreateFlags : u32 { const TRANSIENT =
1779 CommandPoolCreateFlagBits::TRANSIENT.0; const RESET_COMMAND_BUFFER =
1780 CommandPoolCreateFlagBits::RESET_COMMAND_BUFFER.0; const PROTECTED =
1781 CommandPoolCreateFlagBits::PROTECTED.0; }
1782}
1783#[doc(alias = "VkCommandPoolCreateFlagBits")]
1785#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1786#[repr(transparent)]
1787pub struct CommandPoolCreateFlagBits(pub u32);
1788impl CommandPoolCreateFlagBits {
1789 #[inline]
1790 pub const fn bitmask(&self) -> CommandPoolCreateFlags {
1792 CommandPoolCreateFlags::from_bits_truncate(self.0)
1793 }
1794}
1795impl std::fmt::Debug for CommandPoolCreateFlagBits {
1796 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1797 f.write_str(
1798 match self {
1799 &Self::TRANSIENT => "TRANSIENT",
1800 &Self::RESET_COMMAND_BUFFER => "RESET_COMMAND_BUFFER",
1801 &Self::PROTECTED => "PROTECTED",
1802 _ => "(unknown variant)",
1803 },
1804 )
1805 }
1806}
1807impl crate::vk1_0::CommandPoolCreateFlagBits {
1809 pub const TRANSIENT: Self = Self(1);
1810 pub const RESET_COMMAND_BUFFER: Self = Self(2);
1811}
1812bitflags::bitflags! {
1813 #[doc =
1814 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolResetFlags.html) · Bitmask of [`CommandPoolResetFlagBits`]"]
1815 #[doc(alias = "VkCommandPoolResetFlags")] #[derive(Default)] #[repr(transparent)] pub
1816 struct CommandPoolResetFlags : u32 { const RELEASE_RESOURCES =
1817 CommandPoolResetFlagBits::RELEASE_RESOURCES.0; }
1818}
1819#[doc(alias = "VkCommandPoolResetFlagBits")]
1821#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1822#[repr(transparent)]
1823pub struct CommandPoolResetFlagBits(pub u32);
1824impl CommandPoolResetFlagBits {
1825 #[inline]
1826 pub const fn bitmask(&self) -> CommandPoolResetFlags {
1828 CommandPoolResetFlags::from_bits_truncate(self.0)
1829 }
1830}
1831impl std::fmt::Debug for CommandPoolResetFlagBits {
1832 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1833 f.write_str(
1834 match self {
1835 &Self::RELEASE_RESOURCES => "RELEASE_RESOURCES",
1836 _ => "(unknown variant)",
1837 },
1838 )
1839 }
1840}
1841impl crate::vk1_0::CommandPoolResetFlagBits {
1843 pub const RELEASE_RESOURCES: Self = Self(1);
1844}
1845bitflags::bitflags! {
1846 #[doc =
1847 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferResetFlags.html) · Bitmask of [`CommandBufferResetFlagBits`]"]
1848 #[doc(alias = "VkCommandBufferResetFlags")] #[derive(Default)] #[repr(transparent)]
1849 pub struct CommandBufferResetFlags : u32 { const RELEASE_RESOURCES =
1850 CommandBufferResetFlagBits::RELEASE_RESOURCES.0; }
1851}
1852#[doc(alias = "VkCommandBufferResetFlagBits")]
1854#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1855#[repr(transparent)]
1856pub struct CommandBufferResetFlagBits(pub u32);
1857impl CommandBufferResetFlagBits {
1858 #[inline]
1859 pub const fn bitmask(&self) -> CommandBufferResetFlags {
1861 CommandBufferResetFlags::from_bits_truncate(self.0)
1862 }
1863}
1864impl std::fmt::Debug for CommandBufferResetFlagBits {
1865 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1866 f.write_str(
1867 match self {
1868 &Self::RELEASE_RESOURCES => "RELEASE_RESOURCES",
1869 _ => "(unknown variant)",
1870 },
1871 )
1872 }
1873}
1874impl crate::vk1_0::CommandBufferResetFlagBits {
1876 pub const RELEASE_RESOURCES: Self = Self(1);
1877}
1878#[doc(alias = "VkCommandBufferLevel")]
1880#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1881#[repr(transparent)]
1882pub struct CommandBufferLevel(pub i32);
1883impl std::fmt::Debug for CommandBufferLevel {
1884 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1885 f.write_str(
1886 match self {
1887 &Self::PRIMARY => "PRIMARY",
1888 &Self::SECONDARY => "SECONDARY",
1889 _ => "(unknown variant)",
1890 },
1891 )
1892 }
1893}
1894impl crate::vk1_0::CommandBufferLevel {
1896 pub const PRIMARY: Self = Self(0);
1897 pub const SECONDARY: Self = Self(1);
1898}
1899bitflags::bitflags! {
1900 #[doc =
1901 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferUsageFlags.html) · Bitmask of [`CommandBufferUsageFlagBits`]"]
1902 #[doc(alias = "VkCommandBufferUsageFlags")] #[derive(Default)] #[repr(transparent)]
1903 pub struct CommandBufferUsageFlags : u32 { const ONE_TIME_SUBMIT =
1904 CommandBufferUsageFlagBits::ONE_TIME_SUBMIT.0; const RENDER_PASS_CONTINUE =
1905 CommandBufferUsageFlagBits::RENDER_PASS_CONTINUE.0; const SIMULTANEOUS_USE =
1906 CommandBufferUsageFlagBits::SIMULTANEOUS_USE.0; }
1907}
1908#[doc(alias = "VkCommandBufferUsageFlagBits")]
1910#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1911#[repr(transparent)]
1912pub struct CommandBufferUsageFlagBits(pub u32);
1913impl CommandBufferUsageFlagBits {
1914 #[inline]
1915 pub const fn bitmask(&self) -> CommandBufferUsageFlags {
1917 CommandBufferUsageFlags::from_bits_truncate(self.0)
1918 }
1919}
1920impl std::fmt::Debug for CommandBufferUsageFlagBits {
1921 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1922 f.write_str(
1923 match self {
1924 &Self::ONE_TIME_SUBMIT => "ONE_TIME_SUBMIT",
1925 &Self::RENDER_PASS_CONTINUE => "RENDER_PASS_CONTINUE",
1926 &Self::SIMULTANEOUS_USE => "SIMULTANEOUS_USE",
1927 _ => "(unknown variant)",
1928 },
1929 )
1930 }
1931}
1932impl crate::vk1_0::CommandBufferUsageFlagBits {
1934 pub const ONE_TIME_SUBMIT: Self = Self(1);
1935 pub const RENDER_PASS_CONTINUE: Self = Self(2);
1936 pub const SIMULTANEOUS_USE: Self = Self(4);
1937}
1938#[doc(alias = "VkCompareOp")]
1940#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1941#[repr(transparent)]
1942pub struct CompareOp(pub i32);
1943impl std::fmt::Debug for CompareOp {
1944 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1945 f.write_str(
1946 match self {
1947 &Self::NEVER => "NEVER",
1948 &Self::LESS => "LESS",
1949 &Self::EQUAL => "EQUAL",
1950 &Self::LESS_OR_EQUAL => "LESS_OR_EQUAL",
1951 &Self::GREATER => "GREATER",
1952 &Self::NOT_EQUAL => "NOT_EQUAL",
1953 &Self::GREATER_OR_EQUAL => "GREATER_OR_EQUAL",
1954 &Self::ALWAYS => "ALWAYS",
1955 _ => "(unknown variant)",
1956 },
1957 )
1958 }
1959}
1960impl crate::vk1_0::CompareOp {
1962 pub const NEVER: Self = Self(0);
1963 pub const LESS: Self = Self(1);
1964 pub const EQUAL: Self = Self(2);
1965 pub const LESS_OR_EQUAL: Self = Self(3);
1966 pub const GREATER: Self = Self(4);
1967 pub const NOT_EQUAL: Self = Self(5);
1968 pub const GREATER_OR_EQUAL: Self = Self(6);
1969 pub const ALWAYS: Self = Self(7);
1970}
1971bitflags::bitflags! {
1972 #[doc =
1973 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCullModeFlags.html) · Bitmask of [`CullModeFlagBits`]"]
1974 #[doc(alias = "VkCullModeFlags")] #[derive(Default)] #[repr(transparent)] pub struct
1975 CullModeFlags : u32 { const NONE = CullModeFlagBits::NONE.0; const FRONT =
1976 CullModeFlagBits::FRONT.0; const BACK = CullModeFlagBits::BACK.0; const
1977 FRONT_AND_BACK = CullModeFlagBits::FRONT_AND_BACK.0; }
1978}
1979#[doc(alias = "VkCullModeFlagBits")]
1981#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
1982#[repr(transparent)]
1983pub struct CullModeFlagBits(pub u32);
1984impl CullModeFlagBits {
1985 #[inline]
1986 pub const fn bitmask(&self) -> CullModeFlags {
1988 CullModeFlags::from_bits_truncate(self.0)
1989 }
1990}
1991impl std::fmt::Debug for CullModeFlagBits {
1992 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1993 f.write_str(
1994 match self {
1995 &Self::NONE => "NONE",
1996 &Self::FRONT => "FRONT",
1997 &Self::BACK => "BACK",
1998 &Self::FRONT_AND_BACK => "FRONT_AND_BACK",
1999 _ => "(unknown variant)",
2000 },
2001 )
2002 }
2003}
2004impl crate::vk1_0::CullModeFlagBits {
2006 pub const NONE: Self = Self(0);
2007 pub const FRONT: Self = Self(1);
2008 pub const BACK: Self = Self(2);
2009 pub const FRONT_AND_BACK: Self = Self(3);
2010}
2011#[doc(alias = "VkDescriptorType")]
2013#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2014#[repr(transparent)]
2015pub struct DescriptorType(pub i32);
2016impl std::fmt::Debug for DescriptorType {
2017 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2018 f.write_str(
2019 match self {
2020 &Self::SAMPLER => "SAMPLER",
2021 &Self::COMBINED_IMAGE_SAMPLER => "COMBINED_IMAGE_SAMPLER",
2022 &Self::SAMPLED_IMAGE => "SAMPLED_IMAGE",
2023 &Self::STORAGE_IMAGE => "STORAGE_IMAGE",
2024 &Self::UNIFORM_TEXEL_BUFFER => "UNIFORM_TEXEL_BUFFER",
2025 &Self::STORAGE_TEXEL_BUFFER => "STORAGE_TEXEL_BUFFER",
2026 &Self::UNIFORM_BUFFER => "UNIFORM_BUFFER",
2027 &Self::STORAGE_BUFFER => "STORAGE_BUFFER",
2028 &Self::UNIFORM_BUFFER_DYNAMIC => "UNIFORM_BUFFER_DYNAMIC",
2029 &Self::STORAGE_BUFFER_DYNAMIC => "STORAGE_BUFFER_DYNAMIC",
2030 &Self::INPUT_ATTACHMENT => "INPUT_ATTACHMENT",
2031 &Self::INLINE_UNIFORM_BLOCK => "INLINE_UNIFORM_BLOCK",
2032 &Self::ACCELERATION_STRUCTURE_KHR => "ACCELERATION_STRUCTURE_KHR",
2033 &Self::ACCELERATION_STRUCTURE_NV => "ACCELERATION_STRUCTURE_NV",
2034 &Self::MUTABLE_VALVE => "MUTABLE_VALVE",
2035 _ => "(unknown variant)",
2036 },
2037 )
2038 }
2039}
2040impl crate::vk1_0::DescriptorType {
2042 pub const SAMPLER: Self = Self(0);
2043 pub const COMBINED_IMAGE_SAMPLER: Self = Self(1);
2044 pub const SAMPLED_IMAGE: Self = Self(2);
2045 pub const STORAGE_IMAGE: Self = Self(3);
2046 pub const UNIFORM_TEXEL_BUFFER: Self = Self(4);
2047 pub const STORAGE_TEXEL_BUFFER: Self = Self(5);
2048 pub const UNIFORM_BUFFER: Self = Self(6);
2049 pub const STORAGE_BUFFER: Self = Self(7);
2050 pub const UNIFORM_BUFFER_DYNAMIC: Self = Self(8);
2051 pub const STORAGE_BUFFER_DYNAMIC: Self = Self(9);
2052 pub const INPUT_ATTACHMENT: Self = Self(10);
2053}
2054#[doc(alias = "VkDynamicState")]
2056#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2057#[repr(transparent)]
2058pub struct DynamicState(pub i32);
2059impl std::fmt::Debug for DynamicState {
2060 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2061 f.write_str(
2062 match self {
2063 &Self::VIEWPORT => "VIEWPORT",
2064 &Self::SCISSOR => "SCISSOR",
2065 &Self::LINE_WIDTH => "LINE_WIDTH",
2066 &Self::DEPTH_BIAS => "DEPTH_BIAS",
2067 &Self::BLEND_CONSTANTS => "BLEND_CONSTANTS",
2068 &Self::DEPTH_BOUNDS => "DEPTH_BOUNDS",
2069 &Self::STENCIL_COMPARE_MASK => "STENCIL_COMPARE_MASK",
2070 &Self::STENCIL_WRITE_MASK => "STENCIL_WRITE_MASK",
2071 &Self::STENCIL_REFERENCE => "STENCIL_REFERENCE",
2072 &Self::CULL_MODE => "CULL_MODE",
2073 &Self::FRONT_FACE => "FRONT_FACE",
2074 &Self::PRIMITIVE_TOPOLOGY => "PRIMITIVE_TOPOLOGY",
2075 &Self::VIEWPORT_WITH_COUNT => "VIEWPORT_WITH_COUNT",
2076 &Self::SCISSOR_WITH_COUNT => "SCISSOR_WITH_COUNT",
2077 &Self::VERTEX_INPUT_BINDING_STRIDE => "VERTEX_INPUT_BINDING_STRIDE",
2078 &Self::DEPTH_TEST_ENABLE => "DEPTH_TEST_ENABLE",
2079 &Self::DEPTH_WRITE_ENABLE => "DEPTH_WRITE_ENABLE",
2080 &Self::DEPTH_COMPARE_OP => "DEPTH_COMPARE_OP",
2081 &Self::DEPTH_BOUNDS_TEST_ENABLE => "DEPTH_BOUNDS_TEST_ENABLE",
2082 &Self::STENCIL_TEST_ENABLE => "STENCIL_TEST_ENABLE",
2083 &Self::STENCIL_OP => "STENCIL_OP",
2084 &Self::RASTERIZER_DISCARD_ENABLE => "RASTERIZER_DISCARD_ENABLE",
2085 &Self::DEPTH_BIAS_ENABLE => "DEPTH_BIAS_ENABLE",
2086 &Self::PRIMITIVE_RESTART_ENABLE => "PRIMITIVE_RESTART_ENABLE",
2087 &Self::VIEWPORT_W_SCALING_NV => "VIEWPORT_W_SCALING_NV",
2088 &Self::DISCARD_RECTANGLE_EXT => "DISCARD_RECTANGLE_EXT",
2089 &Self::SAMPLE_LOCATIONS_EXT => "SAMPLE_LOCATIONS_EXT",
2090 &Self::RAY_TRACING_PIPELINE_STACK_SIZE_KHR => {
2091 "RAY_TRACING_PIPELINE_STACK_SIZE_KHR"
2092 }
2093 &Self::VIEWPORT_SHADING_RATE_PALETTE_NV => {
2094 "VIEWPORT_SHADING_RATE_PALETTE_NV"
2095 }
2096 &Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => {
2097 "VIEWPORT_COARSE_SAMPLE_ORDER_NV"
2098 }
2099 &Self::EXCLUSIVE_SCISSOR_NV => "EXCLUSIVE_SCISSOR_NV",
2100 &Self::FRAGMENT_SHADING_RATE_KHR => "FRAGMENT_SHADING_RATE_KHR",
2101 &Self::LINE_STIPPLE_EXT => "LINE_STIPPLE_EXT",
2102 &Self::VERTEX_INPUT_EXT => "VERTEX_INPUT_EXT",
2103 &Self::PATCH_CONTROL_POINTS_EXT => "PATCH_CONTROL_POINTS_EXT",
2104 &Self::LOGIC_OP_EXT => "LOGIC_OP_EXT",
2105 &Self::COLOR_WRITE_ENABLE_EXT => "COLOR_WRITE_ENABLE_EXT",
2106 _ => "(unknown variant)",
2107 },
2108 )
2109 }
2110}
2111impl crate::vk1_0::DynamicState {
2113 pub const VIEWPORT: Self = Self(0);
2114 pub const SCISSOR: Self = Self(1);
2115 pub const LINE_WIDTH: Self = Self(2);
2116 pub const DEPTH_BIAS: Self = Self(3);
2117 pub const BLEND_CONSTANTS: Self = Self(4);
2118 pub const DEPTH_BOUNDS: Self = Self(5);
2119 pub const STENCIL_COMPARE_MASK: Self = Self(6);
2120 pub const STENCIL_WRITE_MASK: Self = Self(7);
2121 pub const STENCIL_REFERENCE: Self = Self(8);
2122}
2123bitflags::bitflags! {
2124 #[doc =
2125 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateFlags.html) · Bitmask of [`FenceCreateFlagBits`]"]
2126 #[doc(alias = "VkFenceCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
2127 struct FenceCreateFlags : u32 { const SIGNALED = FenceCreateFlagBits::SIGNALED.0; }
2128}
2129#[doc(alias = "VkFenceCreateFlagBits")]
2131#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2132#[repr(transparent)]
2133pub struct FenceCreateFlagBits(pub u32);
2134impl FenceCreateFlagBits {
2135 #[inline]
2136 pub const fn bitmask(&self) -> FenceCreateFlags {
2138 FenceCreateFlags::from_bits_truncate(self.0)
2139 }
2140}
2141impl std::fmt::Debug for FenceCreateFlagBits {
2142 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2143 f.write_str(
2144 match self {
2145 &Self::SIGNALED => "SIGNALED",
2146 _ => "(unknown variant)",
2147 },
2148 )
2149 }
2150}
2151impl crate::vk1_0::FenceCreateFlagBits {
2153 pub const SIGNALED: Self = Self(1);
2154}
2155#[doc(alias = "VkPolygonMode")]
2157#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2158#[repr(transparent)]
2159pub struct PolygonMode(pub i32);
2160impl std::fmt::Debug for PolygonMode {
2161 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2162 f.write_str(
2163 match self {
2164 &Self::FILL => "FILL",
2165 &Self::LINE => "LINE",
2166 &Self::POINT => "POINT",
2167 &Self::FILL_RECTANGLE_NV => "FILL_RECTANGLE_NV",
2168 _ => "(unknown variant)",
2169 },
2170 )
2171 }
2172}
2173impl crate::vk1_0::PolygonMode {
2175 pub const FILL: Self = Self(0);
2176 pub const LINE: Self = Self(1);
2177 pub const POINT: Self = Self(2);
2178}
2179#[doc(alias = "VkFormat")]
2181#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2182#[repr(transparent)]
2183pub struct Format(pub i32);
2184impl std::fmt::Debug for Format {
2185 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2186 f.write_str(
2187 match self {
2188 &Self::UNDEFINED => "UNDEFINED",
2189 &Self::R4G4_UNORM_PACK8 => "R4G4_UNORM_PACK8",
2190 &Self::R4G4B4A4_UNORM_PACK16 => "R4G4B4A4_UNORM_PACK16",
2191 &Self::B4G4R4A4_UNORM_PACK16 => "B4G4R4A4_UNORM_PACK16",
2192 &Self::R5G6B5_UNORM_PACK16 => "R5G6B5_UNORM_PACK16",
2193 &Self::B5G6R5_UNORM_PACK16 => "B5G6R5_UNORM_PACK16",
2194 &Self::R5G5B5A1_UNORM_PACK16 => "R5G5B5A1_UNORM_PACK16",
2195 &Self::B5G5R5A1_UNORM_PACK16 => "B5G5R5A1_UNORM_PACK16",
2196 &Self::A1R5G5B5_UNORM_PACK16 => "A1R5G5B5_UNORM_PACK16",
2197 &Self::R8_UNORM => "R8_UNORM",
2198 &Self::R8_SNORM => "R8_SNORM",
2199 &Self::R8_USCALED => "R8_USCALED",
2200 &Self::R8_SSCALED => "R8_SSCALED",
2201 &Self::R8_UINT => "R8_UINT",
2202 &Self::R8_SINT => "R8_SINT",
2203 &Self::R8_SRGB => "R8_SRGB",
2204 &Self::R8G8_UNORM => "R8G8_UNORM",
2205 &Self::R8G8_SNORM => "R8G8_SNORM",
2206 &Self::R8G8_USCALED => "R8G8_USCALED",
2207 &Self::R8G8_SSCALED => "R8G8_SSCALED",
2208 &Self::R8G8_UINT => "R8G8_UINT",
2209 &Self::R8G8_SINT => "R8G8_SINT",
2210 &Self::R8G8_SRGB => "R8G8_SRGB",
2211 &Self::R8G8B8_UNORM => "R8G8B8_UNORM",
2212 &Self::R8G8B8_SNORM => "R8G8B8_SNORM",
2213 &Self::R8G8B8_USCALED => "R8G8B8_USCALED",
2214 &Self::R8G8B8_SSCALED => "R8G8B8_SSCALED",
2215 &Self::R8G8B8_UINT => "R8G8B8_UINT",
2216 &Self::R8G8B8_SINT => "R8G8B8_SINT",
2217 &Self::R8G8B8_SRGB => "R8G8B8_SRGB",
2218 &Self::B8G8R8_UNORM => "B8G8R8_UNORM",
2219 &Self::B8G8R8_SNORM => "B8G8R8_SNORM",
2220 &Self::B8G8R8_USCALED => "B8G8R8_USCALED",
2221 &Self::B8G8R8_SSCALED => "B8G8R8_SSCALED",
2222 &Self::B8G8R8_UINT => "B8G8R8_UINT",
2223 &Self::B8G8R8_SINT => "B8G8R8_SINT",
2224 &Self::B8G8R8_SRGB => "B8G8R8_SRGB",
2225 &Self::R8G8B8A8_UNORM => "R8G8B8A8_UNORM",
2226 &Self::R8G8B8A8_SNORM => "R8G8B8A8_SNORM",
2227 &Self::R8G8B8A8_USCALED => "R8G8B8A8_USCALED",
2228 &Self::R8G8B8A8_SSCALED => "R8G8B8A8_SSCALED",
2229 &Self::R8G8B8A8_UINT => "R8G8B8A8_UINT",
2230 &Self::R8G8B8A8_SINT => "R8G8B8A8_SINT",
2231 &Self::R8G8B8A8_SRGB => "R8G8B8A8_SRGB",
2232 &Self::B8G8R8A8_UNORM => "B8G8R8A8_UNORM",
2233 &Self::B8G8R8A8_SNORM => "B8G8R8A8_SNORM",
2234 &Self::B8G8R8A8_USCALED => "B8G8R8A8_USCALED",
2235 &Self::B8G8R8A8_SSCALED => "B8G8R8A8_SSCALED",
2236 &Self::B8G8R8A8_UINT => "B8G8R8A8_UINT",
2237 &Self::B8G8R8A8_SINT => "B8G8R8A8_SINT",
2238 &Self::B8G8R8A8_SRGB => "B8G8R8A8_SRGB",
2239 &Self::A8B8G8R8_UNORM_PACK32 => "A8B8G8R8_UNORM_PACK32",
2240 &Self::A8B8G8R8_SNORM_PACK32 => "A8B8G8R8_SNORM_PACK32",
2241 &Self::A8B8G8R8_USCALED_PACK32 => "A8B8G8R8_USCALED_PACK32",
2242 &Self::A8B8G8R8_SSCALED_PACK32 => "A8B8G8R8_SSCALED_PACK32",
2243 &Self::A8B8G8R8_UINT_PACK32 => "A8B8G8R8_UINT_PACK32",
2244 &Self::A8B8G8R8_SINT_PACK32 => "A8B8G8R8_SINT_PACK32",
2245 &Self::A8B8G8R8_SRGB_PACK32 => "A8B8G8R8_SRGB_PACK32",
2246 &Self::A2R10G10B10_UNORM_PACK32 => "A2R10G10B10_UNORM_PACK32",
2247 &Self::A2R10G10B10_SNORM_PACK32 => "A2R10G10B10_SNORM_PACK32",
2248 &Self::A2R10G10B10_USCALED_PACK32 => "A2R10G10B10_USCALED_PACK32",
2249 &Self::A2R10G10B10_SSCALED_PACK32 => "A2R10G10B10_SSCALED_PACK32",
2250 &Self::A2R10G10B10_UINT_PACK32 => "A2R10G10B10_UINT_PACK32",
2251 &Self::A2R10G10B10_SINT_PACK32 => "A2R10G10B10_SINT_PACK32",
2252 &Self::A2B10G10R10_UNORM_PACK32 => "A2B10G10R10_UNORM_PACK32",
2253 &Self::A2B10G10R10_SNORM_PACK32 => "A2B10G10R10_SNORM_PACK32",
2254 &Self::A2B10G10R10_USCALED_PACK32 => "A2B10G10R10_USCALED_PACK32",
2255 &Self::A2B10G10R10_SSCALED_PACK32 => "A2B10G10R10_SSCALED_PACK32",
2256 &Self::A2B10G10R10_UINT_PACK32 => "A2B10G10R10_UINT_PACK32",
2257 &Self::A2B10G10R10_SINT_PACK32 => "A2B10G10R10_SINT_PACK32",
2258 &Self::R16_UNORM => "R16_UNORM",
2259 &Self::R16_SNORM => "R16_SNORM",
2260 &Self::R16_USCALED => "R16_USCALED",
2261 &Self::R16_SSCALED => "R16_SSCALED",
2262 &Self::R16_UINT => "R16_UINT",
2263 &Self::R16_SINT => "R16_SINT",
2264 &Self::R16_SFLOAT => "R16_SFLOAT",
2265 &Self::R16G16_UNORM => "R16G16_UNORM",
2266 &Self::R16G16_SNORM => "R16G16_SNORM",
2267 &Self::R16G16_USCALED => "R16G16_USCALED",
2268 &Self::R16G16_SSCALED => "R16G16_SSCALED",
2269 &Self::R16G16_UINT => "R16G16_UINT",
2270 &Self::R16G16_SINT => "R16G16_SINT",
2271 &Self::R16G16_SFLOAT => "R16G16_SFLOAT",
2272 &Self::R16G16B16_UNORM => "R16G16B16_UNORM",
2273 &Self::R16G16B16_SNORM => "R16G16B16_SNORM",
2274 &Self::R16G16B16_USCALED => "R16G16B16_USCALED",
2275 &Self::R16G16B16_SSCALED => "R16G16B16_SSCALED",
2276 &Self::R16G16B16_UINT => "R16G16B16_UINT",
2277 &Self::R16G16B16_SINT => "R16G16B16_SINT",
2278 &Self::R16G16B16_SFLOAT => "R16G16B16_SFLOAT",
2279 &Self::R16G16B16A16_UNORM => "R16G16B16A16_UNORM",
2280 &Self::R16G16B16A16_SNORM => "R16G16B16A16_SNORM",
2281 &Self::R16G16B16A16_USCALED => "R16G16B16A16_USCALED",
2282 &Self::R16G16B16A16_SSCALED => "R16G16B16A16_SSCALED",
2283 &Self::R16G16B16A16_UINT => "R16G16B16A16_UINT",
2284 &Self::R16G16B16A16_SINT => "R16G16B16A16_SINT",
2285 &Self::R16G16B16A16_SFLOAT => "R16G16B16A16_SFLOAT",
2286 &Self::R32_UINT => "R32_UINT",
2287 &Self::R32_SINT => "R32_SINT",
2288 &Self::R32_SFLOAT => "R32_SFLOAT",
2289 &Self::R32G32_UINT => "R32G32_UINT",
2290 &Self::R32G32_SINT => "R32G32_SINT",
2291 &Self::R32G32_SFLOAT => "R32G32_SFLOAT",
2292 &Self::R32G32B32_UINT => "R32G32B32_UINT",
2293 &Self::R32G32B32_SINT => "R32G32B32_SINT",
2294 &Self::R32G32B32_SFLOAT => "R32G32B32_SFLOAT",
2295 &Self::R32G32B32A32_UINT => "R32G32B32A32_UINT",
2296 &Self::R32G32B32A32_SINT => "R32G32B32A32_SINT",
2297 &Self::R32G32B32A32_SFLOAT => "R32G32B32A32_SFLOAT",
2298 &Self::R64_UINT => "R64_UINT",
2299 &Self::R64_SINT => "R64_SINT",
2300 &Self::R64_SFLOAT => "R64_SFLOAT",
2301 &Self::R64G64_UINT => "R64G64_UINT",
2302 &Self::R64G64_SINT => "R64G64_SINT",
2303 &Self::R64G64_SFLOAT => "R64G64_SFLOAT",
2304 &Self::R64G64B64_UINT => "R64G64B64_UINT",
2305 &Self::R64G64B64_SINT => "R64G64B64_SINT",
2306 &Self::R64G64B64_SFLOAT => "R64G64B64_SFLOAT",
2307 &Self::R64G64B64A64_UINT => "R64G64B64A64_UINT",
2308 &Self::R64G64B64A64_SINT => "R64G64B64A64_SINT",
2309 &Self::R64G64B64A64_SFLOAT => "R64G64B64A64_SFLOAT",
2310 &Self::B10G11R11_UFLOAT_PACK32 => "B10G11R11_UFLOAT_PACK32",
2311 &Self::E5B9G9R9_UFLOAT_PACK32 => "E5B9G9R9_UFLOAT_PACK32",
2312 &Self::D16_UNORM => "D16_UNORM",
2313 &Self::X8_D24_UNORM_PACK32 => "X8_D24_UNORM_PACK32",
2314 &Self::D32_SFLOAT => "D32_SFLOAT",
2315 &Self::S8_UINT => "S8_UINT",
2316 &Self::D16_UNORM_S8_UINT => "D16_UNORM_S8_UINT",
2317 &Self::D24_UNORM_S8_UINT => "D24_UNORM_S8_UINT",
2318 &Self::D32_SFLOAT_S8_UINT => "D32_SFLOAT_S8_UINT",
2319 &Self::BC1_RGB_UNORM_BLOCK => "BC1_RGB_UNORM_BLOCK",
2320 &Self::BC1_RGB_SRGB_BLOCK => "BC1_RGB_SRGB_BLOCK",
2321 &Self::BC1_RGBA_UNORM_BLOCK => "BC1_RGBA_UNORM_BLOCK",
2322 &Self::BC1_RGBA_SRGB_BLOCK => "BC1_RGBA_SRGB_BLOCK",
2323 &Self::BC2_UNORM_BLOCK => "BC2_UNORM_BLOCK",
2324 &Self::BC2_SRGB_BLOCK => "BC2_SRGB_BLOCK",
2325 &Self::BC3_UNORM_BLOCK => "BC3_UNORM_BLOCK",
2326 &Self::BC3_SRGB_BLOCK => "BC3_SRGB_BLOCK",
2327 &Self::BC4_UNORM_BLOCK => "BC4_UNORM_BLOCK",
2328 &Self::BC4_SNORM_BLOCK => "BC4_SNORM_BLOCK",
2329 &Self::BC5_UNORM_BLOCK => "BC5_UNORM_BLOCK",
2330 &Self::BC5_SNORM_BLOCK => "BC5_SNORM_BLOCK",
2331 &Self::BC6H_UFLOAT_BLOCK => "BC6H_UFLOAT_BLOCK",
2332 &Self::BC6H_SFLOAT_BLOCK => "BC6H_SFLOAT_BLOCK",
2333 &Self::BC7_UNORM_BLOCK => "BC7_UNORM_BLOCK",
2334 &Self::BC7_SRGB_BLOCK => "BC7_SRGB_BLOCK",
2335 &Self::ETC2_R8G8B8_UNORM_BLOCK => "ETC2_R8G8B8_UNORM_BLOCK",
2336 &Self::ETC2_R8G8B8_SRGB_BLOCK => "ETC2_R8G8B8_SRGB_BLOCK",
2337 &Self::ETC2_R8G8B8A1_UNORM_BLOCK => "ETC2_R8G8B8A1_UNORM_BLOCK",
2338 &Self::ETC2_R8G8B8A1_SRGB_BLOCK => "ETC2_R8G8B8A1_SRGB_BLOCK",
2339 &Self::ETC2_R8G8B8A8_UNORM_BLOCK => "ETC2_R8G8B8A8_UNORM_BLOCK",
2340 &Self::ETC2_R8G8B8A8_SRGB_BLOCK => "ETC2_R8G8B8A8_SRGB_BLOCK",
2341 &Self::EAC_R11_UNORM_BLOCK => "EAC_R11_UNORM_BLOCK",
2342 &Self::EAC_R11_SNORM_BLOCK => "EAC_R11_SNORM_BLOCK",
2343 &Self::EAC_R11G11_UNORM_BLOCK => "EAC_R11G11_UNORM_BLOCK",
2344 &Self::EAC_R11G11_SNORM_BLOCK => "EAC_R11G11_SNORM_BLOCK",
2345 &Self::ASTC_4X4_UNORM_BLOCK => "ASTC_4X4_UNORM_BLOCK",
2346 &Self::ASTC_4X4_SRGB_BLOCK => "ASTC_4X4_SRGB_BLOCK",
2347 &Self::ASTC_5X4_UNORM_BLOCK => "ASTC_5X4_UNORM_BLOCK",
2348 &Self::ASTC_5X4_SRGB_BLOCK => "ASTC_5X4_SRGB_BLOCK",
2349 &Self::ASTC_5X5_UNORM_BLOCK => "ASTC_5X5_UNORM_BLOCK",
2350 &Self::ASTC_5X5_SRGB_BLOCK => "ASTC_5X5_SRGB_BLOCK",
2351 &Self::ASTC_6X5_UNORM_BLOCK => "ASTC_6X5_UNORM_BLOCK",
2352 &Self::ASTC_6X5_SRGB_BLOCK => "ASTC_6X5_SRGB_BLOCK",
2353 &Self::ASTC_6X6_UNORM_BLOCK => "ASTC_6X6_UNORM_BLOCK",
2354 &Self::ASTC_6X6_SRGB_BLOCK => "ASTC_6X6_SRGB_BLOCK",
2355 &Self::ASTC_8X5_UNORM_BLOCK => "ASTC_8X5_UNORM_BLOCK",
2356 &Self::ASTC_8X5_SRGB_BLOCK => "ASTC_8X5_SRGB_BLOCK",
2357 &Self::ASTC_8X6_UNORM_BLOCK => "ASTC_8X6_UNORM_BLOCK",
2358 &Self::ASTC_8X6_SRGB_BLOCK => "ASTC_8X6_SRGB_BLOCK",
2359 &Self::ASTC_8X8_UNORM_BLOCK => "ASTC_8X8_UNORM_BLOCK",
2360 &Self::ASTC_8X8_SRGB_BLOCK => "ASTC_8X8_SRGB_BLOCK",
2361 &Self::ASTC_10X5_UNORM_BLOCK => "ASTC_10X5_UNORM_BLOCK",
2362 &Self::ASTC_10X5_SRGB_BLOCK => "ASTC_10X5_SRGB_BLOCK",
2363 &Self::ASTC_10X6_UNORM_BLOCK => "ASTC_10X6_UNORM_BLOCK",
2364 &Self::ASTC_10X6_SRGB_BLOCK => "ASTC_10X6_SRGB_BLOCK",
2365 &Self::ASTC_10X8_UNORM_BLOCK => "ASTC_10X8_UNORM_BLOCK",
2366 &Self::ASTC_10X8_SRGB_BLOCK => "ASTC_10X8_SRGB_BLOCK",
2367 &Self::ASTC_10X10_UNORM_BLOCK => "ASTC_10X10_UNORM_BLOCK",
2368 &Self::ASTC_10X10_SRGB_BLOCK => "ASTC_10X10_SRGB_BLOCK",
2369 &Self::ASTC_12X10_UNORM_BLOCK => "ASTC_12X10_UNORM_BLOCK",
2370 &Self::ASTC_12X10_SRGB_BLOCK => "ASTC_12X10_SRGB_BLOCK",
2371 &Self::ASTC_12X12_UNORM_BLOCK => "ASTC_12X12_UNORM_BLOCK",
2372 &Self::ASTC_12X12_SRGB_BLOCK => "ASTC_12X12_SRGB_BLOCK",
2373 &Self::G8B8G8R8_422_UNORM => "G8B8G8R8_422_UNORM",
2374 &Self::B8G8R8G8_422_UNORM => "B8G8R8G8_422_UNORM",
2375 &Self::G8_B8_R8_3PLANE_420_UNORM => "G8_B8_R8_3PLANE_420_UNORM",
2376 &Self::G8_B8R8_2PLANE_420_UNORM => "G8_B8R8_2PLANE_420_UNORM",
2377 &Self::G8_B8_R8_3PLANE_422_UNORM => "G8_B8_R8_3PLANE_422_UNORM",
2378 &Self::G8_B8R8_2PLANE_422_UNORM => "G8_B8R8_2PLANE_422_UNORM",
2379 &Self::G8_B8_R8_3PLANE_444_UNORM => "G8_B8_R8_3PLANE_444_UNORM",
2380 &Self::R10X6_UNORM_PACK16 => "R10X6_UNORM_PACK16",
2381 &Self::R10X6G10X6_UNORM_2PACK16 => "R10X6G10X6_UNORM_2PACK16",
2382 &Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => {
2383 "R10X6G10X6B10X6A10X6_UNORM_4PACK16"
2384 }
2385 &Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => {
2386 "G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"
2387 }
2388 &Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => {
2389 "B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"
2390 }
2391 &Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => {
2392 "G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"
2393 }
2394 &Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => {
2395 "G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"
2396 }
2397 &Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => {
2398 "G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"
2399 }
2400 &Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => {
2401 "G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"
2402 }
2403 &Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => {
2404 "G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"
2405 }
2406 &Self::R12X4_UNORM_PACK16 => "R12X4_UNORM_PACK16",
2407 &Self::R12X4G12X4_UNORM_2PACK16 => "R12X4G12X4_UNORM_2PACK16",
2408 &Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => {
2409 "R12X4G12X4B12X4A12X4_UNORM_4PACK16"
2410 }
2411 &Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => {
2412 "G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"
2413 }
2414 &Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => {
2415 "B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"
2416 }
2417 &Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => {
2418 "G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"
2419 }
2420 &Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => {
2421 "G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"
2422 }
2423 &Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => {
2424 "G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"
2425 }
2426 &Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => {
2427 "G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"
2428 }
2429 &Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => {
2430 "G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"
2431 }
2432 &Self::G16B16G16R16_422_UNORM => "G16B16G16R16_422_UNORM",
2433 &Self::B16G16R16G16_422_UNORM => "B16G16R16G16_422_UNORM",
2434 &Self::G16_B16_R16_3PLANE_420_UNORM => "G16_B16_R16_3PLANE_420_UNORM",
2435 &Self::G16_B16R16_2PLANE_420_UNORM => "G16_B16R16_2PLANE_420_UNORM",
2436 &Self::G16_B16_R16_3PLANE_422_UNORM => "G16_B16_R16_3PLANE_422_UNORM",
2437 &Self::G16_B16R16_2PLANE_422_UNORM => "G16_B16R16_2PLANE_422_UNORM",
2438 &Self::G16_B16_R16_3PLANE_444_UNORM => "G16_B16_R16_3PLANE_444_UNORM",
2439 &Self::G8_B8R8_2PLANE_444_UNORM => "G8_B8R8_2PLANE_444_UNORM",
2440 &Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 => {
2441 "G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16"
2442 }
2443 &Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 => {
2444 "G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16"
2445 }
2446 &Self::G16_B16R16_2PLANE_444_UNORM => "G16_B16R16_2PLANE_444_UNORM",
2447 &Self::A4R4G4B4_UNORM_PACK16 => "A4R4G4B4_UNORM_PACK16",
2448 &Self::A4B4G4R4_UNORM_PACK16 => "A4B4G4R4_UNORM_PACK16",
2449 &Self::ASTC_4X4_SFLOAT_BLOCK => "ASTC_4X4_SFLOAT_BLOCK",
2450 &Self::ASTC_5X4_SFLOAT_BLOCK => "ASTC_5X4_SFLOAT_BLOCK",
2451 &Self::ASTC_5X5_SFLOAT_BLOCK => "ASTC_5X5_SFLOAT_BLOCK",
2452 &Self::ASTC_6X5_SFLOAT_BLOCK => "ASTC_6X5_SFLOAT_BLOCK",
2453 &Self::ASTC_6X6_SFLOAT_BLOCK => "ASTC_6X6_SFLOAT_BLOCK",
2454 &Self::ASTC_8X5_SFLOAT_BLOCK => "ASTC_8X5_SFLOAT_BLOCK",
2455 &Self::ASTC_8X6_SFLOAT_BLOCK => "ASTC_8X6_SFLOAT_BLOCK",
2456 &Self::ASTC_8X8_SFLOAT_BLOCK => "ASTC_8X8_SFLOAT_BLOCK",
2457 &Self::ASTC_10X5_SFLOAT_BLOCK => "ASTC_10X5_SFLOAT_BLOCK",
2458 &Self::ASTC_10X6_SFLOAT_BLOCK => "ASTC_10X6_SFLOAT_BLOCK",
2459 &Self::ASTC_10X8_SFLOAT_BLOCK => "ASTC_10X8_SFLOAT_BLOCK",
2460 &Self::ASTC_10X10_SFLOAT_BLOCK => "ASTC_10X10_SFLOAT_BLOCK",
2461 &Self::ASTC_12X10_SFLOAT_BLOCK => "ASTC_12X10_SFLOAT_BLOCK",
2462 &Self::ASTC_12X12_SFLOAT_BLOCK => "ASTC_12X12_SFLOAT_BLOCK",
2463 &Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => "PVRTC1_2BPP_UNORM_BLOCK_IMG",
2464 &Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => "PVRTC1_4BPP_UNORM_BLOCK_IMG",
2465 &Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => "PVRTC2_2BPP_UNORM_BLOCK_IMG",
2466 &Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => "PVRTC2_4BPP_UNORM_BLOCK_IMG",
2467 &Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => "PVRTC1_2BPP_SRGB_BLOCK_IMG",
2468 &Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => "PVRTC1_4BPP_SRGB_BLOCK_IMG",
2469 &Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => "PVRTC2_2BPP_SRGB_BLOCK_IMG",
2470 &Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => "PVRTC2_4BPP_SRGB_BLOCK_IMG",
2471 _ => "(unknown variant)",
2472 },
2473 )
2474 }
2475}
2476impl crate::vk1_0::Format {
2478 pub const UNDEFINED: Self = Self(0);
2479 pub const R4G4_UNORM_PACK8: Self = Self(1);
2480 pub const R4G4B4A4_UNORM_PACK16: Self = Self(2);
2481 pub const B4G4R4A4_UNORM_PACK16: Self = Self(3);
2482 pub const R5G6B5_UNORM_PACK16: Self = Self(4);
2483 pub const B5G6R5_UNORM_PACK16: Self = Self(5);
2484 pub const R5G5B5A1_UNORM_PACK16: Self = Self(6);
2485 pub const B5G5R5A1_UNORM_PACK16: Self = Self(7);
2486 pub const A1R5G5B5_UNORM_PACK16: Self = Self(8);
2487 pub const R8_UNORM: Self = Self(9);
2488 pub const R8_SNORM: Self = Self(10);
2489 pub const R8_USCALED: Self = Self(11);
2490 pub const R8_SSCALED: Self = Self(12);
2491 pub const R8_UINT: Self = Self(13);
2492 pub const R8_SINT: Self = Self(14);
2493 pub const R8_SRGB: Self = Self(15);
2494 pub const R8G8_UNORM: Self = Self(16);
2495 pub const R8G8_SNORM: Self = Self(17);
2496 pub const R8G8_USCALED: Self = Self(18);
2497 pub const R8G8_SSCALED: Self = Self(19);
2498 pub const R8G8_UINT: Self = Self(20);
2499 pub const R8G8_SINT: Self = Self(21);
2500 pub const R8G8_SRGB: Self = Self(22);
2501 pub const R8G8B8_UNORM: Self = Self(23);
2502 pub const R8G8B8_SNORM: Self = Self(24);
2503 pub const R8G8B8_USCALED: Self = Self(25);
2504 pub const R8G8B8_SSCALED: Self = Self(26);
2505 pub const R8G8B8_UINT: Self = Self(27);
2506 pub const R8G8B8_SINT: Self = Self(28);
2507 pub const R8G8B8_SRGB: Self = Self(29);
2508 pub const B8G8R8_UNORM: Self = Self(30);
2509 pub const B8G8R8_SNORM: Self = Self(31);
2510 pub const B8G8R8_USCALED: Self = Self(32);
2511 pub const B8G8R8_SSCALED: Self = Self(33);
2512 pub const B8G8R8_UINT: Self = Self(34);
2513 pub const B8G8R8_SINT: Self = Self(35);
2514 pub const B8G8R8_SRGB: Self = Self(36);
2515 pub const R8G8B8A8_UNORM: Self = Self(37);
2516 pub const R8G8B8A8_SNORM: Self = Self(38);
2517 pub const R8G8B8A8_USCALED: Self = Self(39);
2518 pub const R8G8B8A8_SSCALED: Self = Self(40);
2519 pub const R8G8B8A8_UINT: Self = Self(41);
2520 pub const R8G8B8A8_SINT: Self = Self(42);
2521 pub const R8G8B8A8_SRGB: Self = Self(43);
2522 pub const B8G8R8A8_UNORM: Self = Self(44);
2523 pub const B8G8R8A8_SNORM: Self = Self(45);
2524 pub const B8G8R8A8_USCALED: Self = Self(46);
2525 pub const B8G8R8A8_SSCALED: Self = Self(47);
2526 pub const B8G8R8A8_UINT: Self = Self(48);
2527 pub const B8G8R8A8_SINT: Self = Self(49);
2528 pub const B8G8R8A8_SRGB: Self = Self(50);
2529 pub const A8B8G8R8_UNORM_PACK32: Self = Self(51);
2530 pub const A8B8G8R8_SNORM_PACK32: Self = Self(52);
2531 pub const A8B8G8R8_USCALED_PACK32: Self = Self(53);
2532 pub const A8B8G8R8_SSCALED_PACK32: Self = Self(54);
2533 pub const A8B8G8R8_UINT_PACK32: Self = Self(55);
2534 pub const A8B8G8R8_SINT_PACK32: Self = Self(56);
2535 pub const A8B8G8R8_SRGB_PACK32: Self = Self(57);
2536 pub const A2R10G10B10_UNORM_PACK32: Self = Self(58);
2537 pub const A2R10G10B10_SNORM_PACK32: Self = Self(59);
2538 pub const A2R10G10B10_USCALED_PACK32: Self = Self(60);
2539 pub const A2R10G10B10_SSCALED_PACK32: Self = Self(61);
2540 pub const A2R10G10B10_UINT_PACK32: Self = Self(62);
2541 pub const A2R10G10B10_SINT_PACK32: Self = Self(63);
2542 pub const A2B10G10R10_UNORM_PACK32: Self = Self(64);
2543 pub const A2B10G10R10_SNORM_PACK32: Self = Self(65);
2544 pub const A2B10G10R10_USCALED_PACK32: Self = Self(66);
2545 pub const A2B10G10R10_SSCALED_PACK32: Self = Self(67);
2546 pub const A2B10G10R10_UINT_PACK32: Self = Self(68);
2547 pub const A2B10G10R10_SINT_PACK32: Self = Self(69);
2548 pub const R16_UNORM: Self = Self(70);
2549 pub const R16_SNORM: Self = Self(71);
2550 pub const R16_USCALED: Self = Self(72);
2551 pub const R16_SSCALED: Self = Self(73);
2552 pub const R16_UINT: Self = Self(74);
2553 pub const R16_SINT: Self = Self(75);
2554 pub const R16_SFLOAT: Self = Self(76);
2555 pub const R16G16_UNORM: Self = Self(77);
2556 pub const R16G16_SNORM: Self = Self(78);
2557 pub const R16G16_USCALED: Self = Self(79);
2558 pub const R16G16_SSCALED: Self = Self(80);
2559 pub const R16G16_UINT: Self = Self(81);
2560 pub const R16G16_SINT: Self = Self(82);
2561 pub const R16G16_SFLOAT: Self = Self(83);
2562 pub const R16G16B16_UNORM: Self = Self(84);
2563 pub const R16G16B16_SNORM: Self = Self(85);
2564 pub const R16G16B16_USCALED: Self = Self(86);
2565 pub const R16G16B16_SSCALED: Self = Self(87);
2566 pub const R16G16B16_UINT: Self = Self(88);
2567 pub const R16G16B16_SINT: Self = Self(89);
2568 pub const R16G16B16_SFLOAT: Self = Self(90);
2569 pub const R16G16B16A16_UNORM: Self = Self(91);
2570 pub const R16G16B16A16_SNORM: Self = Self(92);
2571 pub const R16G16B16A16_USCALED: Self = Self(93);
2572 pub const R16G16B16A16_SSCALED: Self = Self(94);
2573 pub const R16G16B16A16_UINT: Self = Self(95);
2574 pub const R16G16B16A16_SINT: Self = Self(96);
2575 pub const R16G16B16A16_SFLOAT: Self = Self(97);
2576 pub const R32_UINT: Self = Self(98);
2577 pub const R32_SINT: Self = Self(99);
2578 pub const R32_SFLOAT: Self = Self(100);
2579 pub const R32G32_UINT: Self = Self(101);
2580 pub const R32G32_SINT: Self = Self(102);
2581 pub const R32G32_SFLOAT: Self = Self(103);
2582 pub const R32G32B32_UINT: Self = Self(104);
2583 pub const R32G32B32_SINT: Self = Self(105);
2584 pub const R32G32B32_SFLOAT: Self = Self(106);
2585 pub const R32G32B32A32_UINT: Self = Self(107);
2586 pub const R32G32B32A32_SINT: Self = Self(108);
2587 pub const R32G32B32A32_SFLOAT: Self = Self(109);
2588 pub const R64_UINT: Self = Self(110);
2589 pub const R64_SINT: Self = Self(111);
2590 pub const R64_SFLOAT: Self = Self(112);
2591 pub const R64G64_UINT: Self = Self(113);
2592 pub const R64G64_SINT: Self = Self(114);
2593 pub const R64G64_SFLOAT: Self = Self(115);
2594 pub const R64G64B64_UINT: Self = Self(116);
2595 pub const R64G64B64_SINT: Self = Self(117);
2596 pub const R64G64B64_SFLOAT: Self = Self(118);
2597 pub const R64G64B64A64_UINT: Self = Self(119);
2598 pub const R64G64B64A64_SINT: Self = Self(120);
2599 pub const R64G64B64A64_SFLOAT: Self = Self(121);
2600 pub const B10G11R11_UFLOAT_PACK32: Self = Self(122);
2601 pub const E5B9G9R9_UFLOAT_PACK32: Self = Self(123);
2602 pub const D16_UNORM: Self = Self(124);
2603 pub const X8_D24_UNORM_PACK32: Self = Self(125);
2604 pub const D32_SFLOAT: Self = Self(126);
2605 pub const S8_UINT: Self = Self(127);
2606 pub const D16_UNORM_S8_UINT: Self = Self(128);
2607 pub const D24_UNORM_S8_UINT: Self = Self(129);
2608 pub const D32_SFLOAT_S8_UINT: Self = Self(130);
2609 pub const BC1_RGB_UNORM_BLOCK: Self = Self(131);
2610 pub const BC1_RGB_SRGB_BLOCK: Self = Self(132);
2611 pub const BC1_RGBA_UNORM_BLOCK: Self = Self(133);
2612 pub const BC1_RGBA_SRGB_BLOCK: Self = Self(134);
2613 pub const BC2_UNORM_BLOCK: Self = Self(135);
2614 pub const BC2_SRGB_BLOCK: Self = Self(136);
2615 pub const BC3_UNORM_BLOCK: Self = Self(137);
2616 pub const BC3_SRGB_BLOCK: Self = Self(138);
2617 pub const BC4_UNORM_BLOCK: Self = Self(139);
2618 pub const BC4_SNORM_BLOCK: Self = Self(140);
2619 pub const BC5_UNORM_BLOCK: Self = Self(141);
2620 pub const BC5_SNORM_BLOCK: Self = Self(142);
2621 pub const BC6H_UFLOAT_BLOCK: Self = Self(143);
2622 pub const BC6H_SFLOAT_BLOCK: Self = Self(144);
2623 pub const BC7_UNORM_BLOCK: Self = Self(145);
2624 pub const BC7_SRGB_BLOCK: Self = Self(146);
2625 pub const ETC2_R8G8B8_UNORM_BLOCK: Self = Self(147);
2626 pub const ETC2_R8G8B8_SRGB_BLOCK: Self = Self(148);
2627 pub const ETC2_R8G8B8A1_UNORM_BLOCK: Self = Self(149);
2628 pub const ETC2_R8G8B8A1_SRGB_BLOCK: Self = Self(150);
2629 pub const ETC2_R8G8B8A8_UNORM_BLOCK: Self = Self(151);
2630 pub const ETC2_R8G8B8A8_SRGB_BLOCK: Self = Self(152);
2631 pub const EAC_R11_UNORM_BLOCK: Self = Self(153);
2632 pub const EAC_R11_SNORM_BLOCK: Self = Self(154);
2633 pub const EAC_R11G11_UNORM_BLOCK: Self = Self(155);
2634 pub const EAC_R11G11_SNORM_BLOCK: Self = Self(156);
2635 pub const ASTC_4X4_UNORM_BLOCK: Self = Self(157);
2636 pub const ASTC_4X4_SRGB_BLOCK: Self = Self(158);
2637 pub const ASTC_5X4_UNORM_BLOCK: Self = Self(159);
2638 pub const ASTC_5X4_SRGB_BLOCK: Self = Self(160);
2639 pub const ASTC_5X5_UNORM_BLOCK: Self = Self(161);
2640 pub const ASTC_5X5_SRGB_BLOCK: Self = Self(162);
2641 pub const ASTC_6X5_UNORM_BLOCK: Self = Self(163);
2642 pub const ASTC_6X5_SRGB_BLOCK: Self = Self(164);
2643 pub const ASTC_6X6_UNORM_BLOCK: Self = Self(165);
2644 pub const ASTC_6X6_SRGB_BLOCK: Self = Self(166);
2645 pub const ASTC_8X5_UNORM_BLOCK: Self = Self(167);
2646 pub const ASTC_8X5_SRGB_BLOCK: Self = Self(168);
2647 pub const ASTC_8X6_UNORM_BLOCK: Self = Self(169);
2648 pub const ASTC_8X6_SRGB_BLOCK: Self = Self(170);
2649 pub const ASTC_8X8_UNORM_BLOCK: Self = Self(171);
2650 pub const ASTC_8X8_SRGB_BLOCK: Self = Self(172);
2651 pub const ASTC_10X5_UNORM_BLOCK: Self = Self(173);
2652 pub const ASTC_10X5_SRGB_BLOCK: Self = Self(174);
2653 pub const ASTC_10X6_UNORM_BLOCK: Self = Self(175);
2654 pub const ASTC_10X6_SRGB_BLOCK: Self = Self(176);
2655 pub const ASTC_10X8_UNORM_BLOCK: Self = Self(177);
2656 pub const ASTC_10X8_SRGB_BLOCK: Self = Self(178);
2657 pub const ASTC_10X10_UNORM_BLOCK: Self = Self(179);
2658 pub const ASTC_10X10_SRGB_BLOCK: Self = Self(180);
2659 pub const ASTC_12X10_UNORM_BLOCK: Self = Self(181);
2660 pub const ASTC_12X10_SRGB_BLOCK: Self = Self(182);
2661 pub const ASTC_12X12_UNORM_BLOCK: Self = Self(183);
2662 pub const ASTC_12X12_SRGB_BLOCK: Self = Self(184);
2663}
2664bitflags::bitflags! {
2665 #[doc =
2666 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatFeatureFlags.html) · Bitmask of [`FormatFeatureFlagBits`]"]
2667 #[doc(alias = "VkFormatFeatureFlags")] #[derive(Default)] #[repr(transparent)] pub
2668 struct FormatFeatureFlags : u32 { const SAMPLED_IMAGE =
2669 FormatFeatureFlagBits::SAMPLED_IMAGE.0; const STORAGE_IMAGE =
2670 FormatFeatureFlagBits::STORAGE_IMAGE.0; const STORAGE_IMAGE_ATOMIC =
2671 FormatFeatureFlagBits::STORAGE_IMAGE_ATOMIC.0; const UNIFORM_TEXEL_BUFFER =
2672 FormatFeatureFlagBits::UNIFORM_TEXEL_BUFFER.0; const STORAGE_TEXEL_BUFFER =
2673 FormatFeatureFlagBits::STORAGE_TEXEL_BUFFER.0; const STORAGE_TEXEL_BUFFER_ATOMIC =
2674 FormatFeatureFlagBits::STORAGE_TEXEL_BUFFER_ATOMIC.0; const VERTEX_BUFFER =
2675 FormatFeatureFlagBits::VERTEX_BUFFER.0; const COLOR_ATTACHMENT =
2676 FormatFeatureFlagBits::COLOR_ATTACHMENT.0; const COLOR_ATTACHMENT_BLEND =
2677 FormatFeatureFlagBits::COLOR_ATTACHMENT_BLEND.0; const DEPTH_STENCIL_ATTACHMENT =
2678 FormatFeatureFlagBits::DEPTH_STENCIL_ATTACHMENT.0; const BLIT_SRC =
2679 FormatFeatureFlagBits::BLIT_SRC.0; const BLIT_DST = FormatFeatureFlagBits::BLIT_DST
2680 .0; const SAMPLED_IMAGE_FILTER_LINEAR =
2681 FormatFeatureFlagBits::SAMPLED_IMAGE_FILTER_LINEAR.0; const TRANSFER_SRC =
2682 FormatFeatureFlagBits::TRANSFER_SRC.0; const TRANSFER_DST =
2683 FormatFeatureFlagBits::TRANSFER_DST.0; const MIDPOINT_CHROMA_SAMPLES =
2684 FormatFeatureFlagBits::MIDPOINT_CHROMA_SAMPLES.0; const
2685 SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER =
2686 FormatFeatureFlagBits::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER.0; const
2687 SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER =
2688 FormatFeatureFlagBits::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER
2689 .0; const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT =
2690 FormatFeatureFlagBits::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT
2691 .0; const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE =
2692 FormatFeatureFlagBits::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE
2693 .0; const DISJOINT = FormatFeatureFlagBits::DISJOINT.0; const COSITED_CHROMA_SAMPLES
2694 = FormatFeatureFlagBits::COSITED_CHROMA_SAMPLES.0; const SAMPLED_IMAGE_FILTER_MINMAX
2695 = FormatFeatureFlagBits::SAMPLED_IMAGE_FILTER_MINMAX.0; const
2696 SAMPLED_IMAGE_FILTER_CUBIC_IMG =
2697 FormatFeatureFlagBits::SAMPLED_IMAGE_FILTER_CUBIC_IMG.0; const
2698 VIDEO_DECODE_OUTPUT_KHR = FormatFeatureFlagBits::VIDEO_DECODE_OUTPUT_KHR.0; const
2699 VIDEO_DECODE_DPB_KHR = FormatFeatureFlagBits::VIDEO_DECODE_DPB_KHR.0; const
2700 ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR =
2701 FormatFeatureFlagBits::ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR.0; const
2702 FRAGMENT_DENSITY_MAP_EXT = FormatFeatureFlagBits::FRAGMENT_DENSITY_MAP_EXT.0; const
2703 FRAGMENT_SHADING_RATE_ATTACHMENT_KHR =
2704 FormatFeatureFlagBits::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0; const
2705 VIDEO_ENCODE_INPUT_KHR = FormatFeatureFlagBits::VIDEO_ENCODE_INPUT_KHR.0; const
2706 VIDEO_ENCODE_DPB_KHR = FormatFeatureFlagBits::VIDEO_ENCODE_DPB_KHR.0; const
2707 TRANSFER_SRC_KHR = FormatFeatureFlagBits::TRANSFER_SRC_KHR.0; const TRANSFER_DST_KHR
2708 = FormatFeatureFlagBits::TRANSFER_DST_KHR.0; const SAMPLED_IMAGE_FILTER_MINMAX_EXT =
2709 FormatFeatureFlagBits::SAMPLED_IMAGE_FILTER_MINMAX_EXT.0; const
2710 MIDPOINT_CHROMA_SAMPLES_KHR = FormatFeatureFlagBits::MIDPOINT_CHROMA_SAMPLES_KHR.0;
2711 const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR =
2712 FormatFeatureFlagBits::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR.0; const
2713 SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR =
2714 FormatFeatureFlagBits::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR
2715 .0; const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR =
2716 FormatFeatureFlagBits::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR
2717 .0; const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR
2718 =
2719 FormatFeatureFlagBits::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR
2720 .0; const DISJOINT_KHR = FormatFeatureFlagBits::DISJOINT_KHR.0; const
2721 COSITED_CHROMA_SAMPLES_KHR = FormatFeatureFlagBits::COSITED_CHROMA_SAMPLES_KHR.0;
2722 const SAMPLED_IMAGE_FILTER_CUBIC_EXT =
2723 FormatFeatureFlagBits::SAMPLED_IMAGE_FILTER_CUBIC_EXT.0; }
2724}
2725#[doc(alias = "VkFormatFeatureFlagBits")]
2727#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2728#[repr(transparent)]
2729pub struct FormatFeatureFlagBits(pub u32);
2730impl FormatFeatureFlagBits {
2731 #[inline]
2732 pub const fn bitmask(&self) -> FormatFeatureFlags {
2734 FormatFeatureFlags::from_bits_truncate(self.0)
2735 }
2736}
2737impl std::fmt::Debug for FormatFeatureFlagBits {
2738 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2739 f.write_str(
2740 match self {
2741 &Self::SAMPLED_IMAGE => "SAMPLED_IMAGE",
2742 &Self::STORAGE_IMAGE => "STORAGE_IMAGE",
2743 &Self::STORAGE_IMAGE_ATOMIC => "STORAGE_IMAGE_ATOMIC",
2744 &Self::UNIFORM_TEXEL_BUFFER => "UNIFORM_TEXEL_BUFFER",
2745 &Self::STORAGE_TEXEL_BUFFER => "STORAGE_TEXEL_BUFFER",
2746 &Self::STORAGE_TEXEL_BUFFER_ATOMIC => "STORAGE_TEXEL_BUFFER_ATOMIC",
2747 &Self::VERTEX_BUFFER => "VERTEX_BUFFER",
2748 &Self::COLOR_ATTACHMENT => "COLOR_ATTACHMENT",
2749 &Self::COLOR_ATTACHMENT_BLEND => "COLOR_ATTACHMENT_BLEND",
2750 &Self::DEPTH_STENCIL_ATTACHMENT => "DEPTH_STENCIL_ATTACHMENT",
2751 &Self::BLIT_SRC => "BLIT_SRC",
2752 &Self::BLIT_DST => "BLIT_DST",
2753 &Self::SAMPLED_IMAGE_FILTER_LINEAR => "SAMPLED_IMAGE_FILTER_LINEAR",
2754 &Self::TRANSFER_SRC => "TRANSFER_SRC",
2755 &Self::TRANSFER_DST => "TRANSFER_DST",
2756 &Self::MIDPOINT_CHROMA_SAMPLES => "MIDPOINT_CHROMA_SAMPLES",
2757 &Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER => {
2758 "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER"
2759 }
2760 &Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER => {
2761 "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER"
2762 }
2763 &Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT => {
2764 "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT"
2765 }
2766 &Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE => {
2767 "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE"
2768 }
2769 &Self::DISJOINT => "DISJOINT",
2770 &Self::COSITED_CHROMA_SAMPLES => "COSITED_CHROMA_SAMPLES",
2771 &Self::SAMPLED_IMAGE_FILTER_MINMAX => "SAMPLED_IMAGE_FILTER_MINMAX",
2772 &Self::SAMPLED_IMAGE_FILTER_CUBIC_IMG => "SAMPLED_IMAGE_FILTER_CUBIC_IMG",
2773 &Self::VIDEO_DECODE_OUTPUT_KHR => "VIDEO_DECODE_OUTPUT_KHR",
2774 &Self::VIDEO_DECODE_DPB_KHR => "VIDEO_DECODE_DPB_KHR",
2775 &Self::ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR => {
2776 "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR"
2777 }
2778 &Self::FRAGMENT_DENSITY_MAP_EXT => "FRAGMENT_DENSITY_MAP_EXT",
2779 &Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR => {
2780 "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR"
2781 }
2782 &Self::VIDEO_ENCODE_INPUT_KHR => "VIDEO_ENCODE_INPUT_KHR",
2783 &Self::VIDEO_ENCODE_DPB_KHR => "VIDEO_ENCODE_DPB_KHR",
2784 _ => "(unknown variant)",
2785 },
2786 )
2787 }
2788}
2789impl crate::vk1_0::FormatFeatureFlagBits {
2791 pub const SAMPLED_IMAGE: Self = Self(1);
2792 pub const STORAGE_IMAGE: Self = Self(2);
2793 pub const STORAGE_IMAGE_ATOMIC: Self = Self(4);
2794 pub const UNIFORM_TEXEL_BUFFER: Self = Self(8);
2795 pub const STORAGE_TEXEL_BUFFER: Self = Self(16);
2796 pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(32);
2797 pub const VERTEX_BUFFER: Self = Self(64);
2798 pub const COLOR_ATTACHMENT: Self = Self(128);
2799 pub const COLOR_ATTACHMENT_BLEND: Self = Self(256);
2800 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(512);
2801 pub const BLIT_SRC: Self = Self(1024);
2802 pub const BLIT_DST: Self = Self(2048);
2803 pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(4096);
2804}
2805#[doc(alias = "VkFrontFace")]
2807#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2808#[repr(transparent)]
2809pub struct FrontFace(pub i32);
2810impl std::fmt::Debug for FrontFace {
2811 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2812 f.write_str(
2813 match self {
2814 &Self::COUNTER_CLOCKWISE => "COUNTER_CLOCKWISE",
2815 &Self::CLOCKWISE => "CLOCKWISE",
2816 _ => "(unknown variant)",
2817 },
2818 )
2819 }
2820}
2821impl crate::vk1_0::FrontFace {
2823 pub const COUNTER_CLOCKWISE: Self = Self(0);
2824 pub const CLOCKWISE: Self = Self(1);
2825}
2826bitflags::bitflags! {
2827 #[doc =
2828 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageAspectFlags.html) · Bitmask of [`ImageAspectFlagBits`]"]
2829 #[doc(alias = "VkImageAspectFlags")] #[derive(Default)] #[repr(transparent)] pub
2830 struct ImageAspectFlags : u32 { const COLOR = ImageAspectFlagBits::COLOR.0; const
2831 DEPTH = ImageAspectFlagBits::DEPTH.0; const STENCIL = ImageAspectFlagBits::STENCIL.0;
2832 const METADATA = ImageAspectFlagBits::METADATA.0; const PLANE_0 =
2833 ImageAspectFlagBits::PLANE_0.0; const PLANE_1 = ImageAspectFlagBits::PLANE_1.0; const
2834 PLANE_2 = ImageAspectFlagBits::PLANE_2.0; const NONE = ImageAspectFlagBits::NONE.0;
2835 const MEMORY_PLANE_0_EXT = ImageAspectFlagBits::MEMORY_PLANE_0_EXT.0; const
2836 MEMORY_PLANE_1_EXT = ImageAspectFlagBits::MEMORY_PLANE_1_EXT.0; const
2837 MEMORY_PLANE_2_EXT = ImageAspectFlagBits::MEMORY_PLANE_2_EXT.0; const
2838 MEMORY_PLANE_3_EXT = ImageAspectFlagBits::MEMORY_PLANE_3_EXT.0; const PLANE_0_KHR =
2839 ImageAspectFlagBits::PLANE_0_KHR.0; const PLANE_1_KHR =
2840 ImageAspectFlagBits::PLANE_1_KHR.0; const PLANE_2_KHR =
2841 ImageAspectFlagBits::PLANE_2_KHR.0; const NONE_KHR = ImageAspectFlagBits::NONE_KHR.0;
2842 }
2843}
2844#[doc(alias = "VkImageAspectFlagBits")]
2846#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2847#[repr(transparent)]
2848pub struct ImageAspectFlagBits(pub u32);
2849impl ImageAspectFlagBits {
2850 #[inline]
2851 pub const fn bitmask(&self) -> ImageAspectFlags {
2853 ImageAspectFlags::from_bits_truncate(self.0)
2854 }
2855}
2856impl std::fmt::Debug for ImageAspectFlagBits {
2857 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2858 f.write_str(
2859 match self {
2860 &Self::COLOR => "COLOR",
2861 &Self::DEPTH => "DEPTH",
2862 &Self::STENCIL => "STENCIL",
2863 &Self::METADATA => "METADATA",
2864 &Self::PLANE_0 => "PLANE_0",
2865 &Self::PLANE_1 => "PLANE_1",
2866 &Self::PLANE_2 => "PLANE_2",
2867 &Self::NONE => "NONE",
2868 &Self::MEMORY_PLANE_0_EXT => "MEMORY_PLANE_0_EXT",
2869 &Self::MEMORY_PLANE_1_EXT => "MEMORY_PLANE_1_EXT",
2870 &Self::MEMORY_PLANE_2_EXT => "MEMORY_PLANE_2_EXT",
2871 &Self::MEMORY_PLANE_3_EXT => "MEMORY_PLANE_3_EXT",
2872 _ => "(unknown variant)",
2873 },
2874 )
2875 }
2876}
2877impl crate::vk1_0::ImageAspectFlagBits {
2879 pub const COLOR: Self = Self(1);
2880 pub const DEPTH: Self = Self(2);
2881 pub const STENCIL: Self = Self(4);
2882 pub const METADATA: Self = Self(8);
2883}
2884bitflags::bitflags! {
2885 #[doc =
2886 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateFlags.html) · Bitmask of [`ImageCreateFlagBits`]"]
2887 #[doc(alias = "VkImageCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
2888 struct ImageCreateFlags : u32 { const SPARSE_BINDING =
2889 ImageCreateFlagBits::SPARSE_BINDING.0; const SPARSE_RESIDENCY =
2890 ImageCreateFlagBits::SPARSE_RESIDENCY.0; const SPARSE_ALIASED =
2891 ImageCreateFlagBits::SPARSE_ALIASED.0; const MUTABLE_FORMAT =
2892 ImageCreateFlagBits::MUTABLE_FORMAT.0; const CUBE_COMPATIBLE =
2893 ImageCreateFlagBits::CUBE_COMPATIBLE.0; const ALIAS = ImageCreateFlagBits::ALIAS.0;
2894 const SPLIT_INSTANCE_BIND_REGIONS = ImageCreateFlagBits::SPLIT_INSTANCE_BIND_REGIONS
2895 .0; const _2D_ARRAY_COMPATIBLE = ImageCreateFlagBits::_2D_ARRAY_COMPATIBLE.0; const
2896 BLOCK_TEXEL_VIEW_COMPATIBLE = ImageCreateFlagBits::BLOCK_TEXEL_VIEW_COMPATIBLE.0;
2897 const EXTENDED_USAGE = ImageCreateFlagBits::EXTENDED_USAGE.0; const PROTECTED =
2898 ImageCreateFlagBits::PROTECTED.0; const DISJOINT = ImageCreateFlagBits::DISJOINT.0;
2899 const CORNER_SAMPLED_NV = ImageCreateFlagBits::CORNER_SAMPLED_NV.0; const
2900 SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT =
2901 ImageCreateFlagBits::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0; const SUBSAMPLED_EXT =
2902 ImageCreateFlagBits::SUBSAMPLED_EXT.0; const _2D_VIEW_COMPATIBLE_EXT =
2903 ImageCreateFlagBits::_2D_VIEW_COMPATIBLE_EXT.0; const
2904 FRAGMENT_DENSITY_MAP_OFFSET_QCOM =
2905 ImageCreateFlagBits::FRAGMENT_DENSITY_MAP_OFFSET_QCOM.0; const
2906 SPLIT_INSTANCE_BIND_REGIONS_KHR =
2907 ImageCreateFlagBits::SPLIT_INSTANCE_BIND_REGIONS_KHR.0; const
2908 _2D_ARRAY_COMPATIBLE_KHR = ImageCreateFlagBits::_2D_ARRAY_COMPATIBLE_KHR.0; const
2909 BLOCK_TEXEL_VIEW_COMPATIBLE_KHR =
2910 ImageCreateFlagBits::BLOCK_TEXEL_VIEW_COMPATIBLE_KHR.0; const EXTENDED_USAGE_KHR =
2911 ImageCreateFlagBits::EXTENDED_USAGE_KHR.0; const DISJOINT_KHR =
2912 ImageCreateFlagBits::DISJOINT_KHR.0; const ALIAS_KHR = ImageCreateFlagBits::ALIAS_KHR
2913 .0; }
2914}
2915#[doc(alias = "VkImageCreateFlagBits")]
2917#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2918#[repr(transparent)]
2919pub struct ImageCreateFlagBits(pub u32);
2920impl ImageCreateFlagBits {
2921 #[inline]
2922 pub const fn bitmask(&self) -> ImageCreateFlags {
2924 ImageCreateFlags::from_bits_truncate(self.0)
2925 }
2926}
2927impl std::fmt::Debug for ImageCreateFlagBits {
2928 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2929 f.write_str(
2930 match self {
2931 &Self::SPARSE_BINDING => "SPARSE_BINDING",
2932 &Self::SPARSE_RESIDENCY => "SPARSE_RESIDENCY",
2933 &Self::SPARSE_ALIASED => "SPARSE_ALIASED",
2934 &Self::MUTABLE_FORMAT => "MUTABLE_FORMAT",
2935 &Self::CUBE_COMPATIBLE => "CUBE_COMPATIBLE",
2936 &Self::ALIAS => "ALIAS",
2937 &Self::SPLIT_INSTANCE_BIND_REGIONS => "SPLIT_INSTANCE_BIND_REGIONS",
2938 &Self::_2D_ARRAY_COMPATIBLE => "2D_ARRAY_COMPATIBLE",
2939 &Self::BLOCK_TEXEL_VIEW_COMPATIBLE => "BLOCK_TEXEL_VIEW_COMPATIBLE",
2940 &Self::EXTENDED_USAGE => "EXTENDED_USAGE",
2941 &Self::PROTECTED => "PROTECTED",
2942 &Self::DISJOINT => "DISJOINT",
2943 &Self::CORNER_SAMPLED_NV => "CORNER_SAMPLED_NV",
2944 &Self::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT => {
2945 "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT"
2946 }
2947 &Self::SUBSAMPLED_EXT => "SUBSAMPLED_EXT",
2948 &Self::_2D_VIEW_COMPATIBLE_EXT => "2D_VIEW_COMPATIBLE_EXT",
2949 &Self::FRAGMENT_DENSITY_MAP_OFFSET_QCOM => {
2950 "FRAGMENT_DENSITY_MAP_OFFSET_QCOM"
2951 }
2952 _ => "(unknown variant)",
2953 },
2954 )
2955 }
2956}
2957impl crate::vk1_0::ImageCreateFlagBits {
2959 pub const SPARSE_BINDING: Self = Self(1);
2960 pub const SPARSE_RESIDENCY: Self = Self(2);
2961 pub const SPARSE_ALIASED: Self = Self(4);
2962 pub const MUTABLE_FORMAT: Self = Self(8);
2963 pub const CUBE_COMPATIBLE: Self = Self(16);
2964}
2965#[doc(alias = "VkImageLayout")]
2967#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
2968#[repr(transparent)]
2969pub struct ImageLayout(pub i32);
2970impl std::fmt::Debug for ImageLayout {
2971 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2972 f.write_str(
2973 match self {
2974 &Self::UNDEFINED => "UNDEFINED",
2975 &Self::GENERAL => "GENERAL",
2976 &Self::COLOR_ATTACHMENT_OPTIMAL => "COLOR_ATTACHMENT_OPTIMAL",
2977 &Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => {
2978 "DEPTH_STENCIL_ATTACHMENT_OPTIMAL"
2979 }
2980 &Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => {
2981 "DEPTH_STENCIL_READ_ONLY_OPTIMAL"
2982 }
2983 &Self::SHADER_READ_ONLY_OPTIMAL => "SHADER_READ_ONLY_OPTIMAL",
2984 &Self::TRANSFER_SRC_OPTIMAL => "TRANSFER_SRC_OPTIMAL",
2985 &Self::TRANSFER_DST_OPTIMAL => "TRANSFER_DST_OPTIMAL",
2986 &Self::PREINITIALIZED => "PREINITIALIZED",
2987 &Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => {
2988 "DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"
2989 }
2990 &Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => {
2991 "DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"
2992 }
2993 &Self::DEPTH_ATTACHMENT_OPTIMAL => "DEPTH_ATTACHMENT_OPTIMAL",
2994 &Self::DEPTH_READ_ONLY_OPTIMAL => "DEPTH_READ_ONLY_OPTIMAL",
2995 &Self::STENCIL_ATTACHMENT_OPTIMAL => "STENCIL_ATTACHMENT_OPTIMAL",
2996 &Self::STENCIL_READ_ONLY_OPTIMAL => "STENCIL_READ_ONLY_OPTIMAL",
2997 &Self::READ_ONLY_OPTIMAL => "READ_ONLY_OPTIMAL",
2998 &Self::ATTACHMENT_OPTIMAL => "ATTACHMENT_OPTIMAL",
2999 &Self::PRESENT_SRC_KHR => "PRESENT_SRC_KHR",
3000 &Self::VIDEO_DECODE_DST_KHR => "VIDEO_DECODE_DST_KHR",
3001 &Self::VIDEO_DECODE_SRC_KHR => "VIDEO_DECODE_SRC_KHR",
3002 &Self::VIDEO_DECODE_DPB_KHR => "VIDEO_DECODE_DPB_KHR",
3003 &Self::SHARED_PRESENT_KHR => "SHARED_PRESENT_KHR",
3004 &Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => {
3005 "FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"
3006 }
3007 &Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR => {
3008 "FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR"
3009 }
3010 &Self::VIDEO_ENCODE_DST_KHR => "VIDEO_ENCODE_DST_KHR",
3011 &Self::VIDEO_ENCODE_SRC_KHR => "VIDEO_ENCODE_SRC_KHR",
3012 &Self::VIDEO_ENCODE_DPB_KHR => "VIDEO_ENCODE_DPB_KHR",
3013 _ => "(unknown variant)",
3014 },
3015 )
3016 }
3017}
3018impl crate::vk1_0::ImageLayout {
3020 pub const UNDEFINED: Self = Self(0);
3021 pub const GENERAL: Self = Self(1);
3022 pub const COLOR_ATTACHMENT_OPTIMAL: Self = Self(2);
3023 pub const DEPTH_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(3);
3024 pub const DEPTH_STENCIL_READ_ONLY_OPTIMAL: Self = Self(4);
3025 pub const SHADER_READ_ONLY_OPTIMAL: Self = Self(5);
3026 pub const TRANSFER_SRC_OPTIMAL: Self = Self(6);
3027 pub const TRANSFER_DST_OPTIMAL: Self = Self(7);
3028 pub const PREINITIALIZED: Self = Self(8);
3029}
3030#[doc(alias = "VkImageTiling")]
3032#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3033#[repr(transparent)]
3034pub struct ImageTiling(pub i32);
3035impl std::fmt::Debug for ImageTiling {
3036 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3037 f.write_str(
3038 match self {
3039 &Self::OPTIMAL => "OPTIMAL",
3040 &Self::LINEAR => "LINEAR",
3041 &Self::DRM_FORMAT_MODIFIER_EXT => "DRM_FORMAT_MODIFIER_EXT",
3042 _ => "(unknown variant)",
3043 },
3044 )
3045 }
3046}
3047impl crate::vk1_0::ImageTiling {
3049 pub const OPTIMAL: Self = Self(0);
3050 pub const LINEAR: Self = Self(1);
3051}
3052#[doc(alias = "VkImageType")]
3054#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3055#[repr(transparent)]
3056pub struct ImageType(pub i32);
3057impl std::fmt::Debug for ImageType {
3058 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3059 f.write_str(
3060 match self {
3061 &Self::_1D => "1D",
3062 &Self::_2D => "2D",
3063 &Self::_3D => "3D",
3064 _ => "(unknown variant)",
3065 },
3066 )
3067 }
3068}
3069impl crate::vk1_0::ImageType {
3071 pub const _1D: Self = Self(0);
3072 pub const _2D: Self = Self(1);
3073 pub const _3D: Self = Self(2);
3074}
3075bitflags::bitflags! {
3076 #[doc =
3077 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageUsageFlags.html) · Bitmask of [`ImageUsageFlagBits`]"]
3078 #[doc(alias = "VkImageUsageFlags")] #[derive(Default)] #[repr(transparent)] pub
3079 struct ImageUsageFlags : u32 { const TRANSFER_SRC = ImageUsageFlagBits::TRANSFER_SRC
3080 .0; const TRANSFER_DST = ImageUsageFlagBits::TRANSFER_DST.0; const SAMPLED =
3081 ImageUsageFlagBits::SAMPLED.0; const STORAGE = ImageUsageFlagBits::STORAGE.0; const
3082 COLOR_ATTACHMENT = ImageUsageFlagBits::COLOR_ATTACHMENT.0; const
3083 DEPTH_STENCIL_ATTACHMENT = ImageUsageFlagBits::DEPTH_STENCIL_ATTACHMENT.0; const
3084 TRANSIENT_ATTACHMENT = ImageUsageFlagBits::TRANSIENT_ATTACHMENT.0; const
3085 INPUT_ATTACHMENT = ImageUsageFlagBits::INPUT_ATTACHMENT.0; const VIDEO_DECODE_DST_KHR
3086 = ImageUsageFlagBits::VIDEO_DECODE_DST_KHR.0; const VIDEO_DECODE_SRC_KHR =
3087 ImageUsageFlagBits::VIDEO_DECODE_SRC_KHR.0; const VIDEO_DECODE_DPB_KHR =
3088 ImageUsageFlagBits::VIDEO_DECODE_DPB_KHR.0; const FRAGMENT_DENSITY_MAP_EXT =
3089 ImageUsageFlagBits::FRAGMENT_DENSITY_MAP_EXT.0; const
3090 FRAGMENT_SHADING_RATE_ATTACHMENT_KHR =
3091 ImageUsageFlagBits::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0; const
3092 VIDEO_ENCODE_DST_KHR = ImageUsageFlagBits::VIDEO_ENCODE_DST_KHR.0; const
3093 VIDEO_ENCODE_SRC_KHR = ImageUsageFlagBits::VIDEO_ENCODE_SRC_KHR.0; const
3094 VIDEO_ENCODE_DPB_KHR = ImageUsageFlagBits::VIDEO_ENCODE_DPB_KHR.0; const
3095 INVOCATION_MASK_HUAWEI = ImageUsageFlagBits::INVOCATION_MASK_HUAWEI.0; const
3096 SHADING_RATE_IMAGE_NV = ImageUsageFlagBits::SHADING_RATE_IMAGE_NV.0; }
3097}
3098#[doc(alias = "VkImageUsageFlagBits")]
3100#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3101#[repr(transparent)]
3102pub struct ImageUsageFlagBits(pub u32);
3103impl ImageUsageFlagBits {
3104 #[inline]
3105 pub const fn bitmask(&self) -> ImageUsageFlags {
3107 ImageUsageFlags::from_bits_truncate(self.0)
3108 }
3109}
3110impl std::fmt::Debug for ImageUsageFlagBits {
3111 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3112 f.write_str(
3113 match self {
3114 &Self::TRANSFER_SRC => "TRANSFER_SRC",
3115 &Self::TRANSFER_DST => "TRANSFER_DST",
3116 &Self::SAMPLED => "SAMPLED",
3117 &Self::STORAGE => "STORAGE",
3118 &Self::COLOR_ATTACHMENT => "COLOR_ATTACHMENT",
3119 &Self::DEPTH_STENCIL_ATTACHMENT => "DEPTH_STENCIL_ATTACHMENT",
3120 &Self::TRANSIENT_ATTACHMENT => "TRANSIENT_ATTACHMENT",
3121 &Self::INPUT_ATTACHMENT => "INPUT_ATTACHMENT",
3122 &Self::VIDEO_DECODE_DST_KHR => "VIDEO_DECODE_DST_KHR",
3123 &Self::VIDEO_DECODE_SRC_KHR => "VIDEO_DECODE_SRC_KHR",
3124 &Self::VIDEO_DECODE_DPB_KHR => "VIDEO_DECODE_DPB_KHR",
3125 &Self::FRAGMENT_DENSITY_MAP_EXT => "FRAGMENT_DENSITY_MAP_EXT",
3126 &Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR => {
3127 "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR"
3128 }
3129 &Self::VIDEO_ENCODE_DST_KHR => "VIDEO_ENCODE_DST_KHR",
3130 &Self::VIDEO_ENCODE_SRC_KHR => "VIDEO_ENCODE_SRC_KHR",
3131 &Self::VIDEO_ENCODE_DPB_KHR => "VIDEO_ENCODE_DPB_KHR",
3132 &Self::INVOCATION_MASK_HUAWEI => "INVOCATION_MASK_HUAWEI",
3133 _ => "(unknown variant)",
3134 },
3135 )
3136 }
3137}
3138impl crate::vk1_0::ImageUsageFlagBits {
3140 pub const TRANSFER_SRC: Self = Self(1);
3141 pub const TRANSFER_DST: Self = Self(2);
3142 pub const SAMPLED: Self = Self(4);
3143 pub const STORAGE: Self = Self(8);
3144 pub const COLOR_ATTACHMENT: Self = Self(16);
3145 pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(32);
3146 pub const TRANSIENT_ATTACHMENT: Self = Self(64);
3147 pub const INPUT_ATTACHMENT: Self = Self(128);
3148}
3149bitflags::bitflags! {
3150 #[doc =
3151 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateFlags.html) · Bitmask of [`ImageViewCreateFlagBits`]"]
3152 #[doc(alias = "VkImageViewCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
3153 struct ImageViewCreateFlags : u32 { const FRAGMENT_DENSITY_MAP_DYNAMIC_EXT =
3154 ImageViewCreateFlagBits::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0; const
3155 FRAGMENT_DENSITY_MAP_DEFERRED_EXT =
3156 ImageViewCreateFlagBits::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0; }
3157}
3158#[doc(alias = "VkImageViewCreateFlagBits")]
3160#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3161#[repr(transparent)]
3162pub struct ImageViewCreateFlagBits(pub u32);
3163impl ImageViewCreateFlagBits {
3164 #[inline]
3165 pub const fn bitmask(&self) -> ImageViewCreateFlags {
3167 ImageViewCreateFlags::from_bits_truncate(self.0)
3168 }
3169}
3170impl std::fmt::Debug for ImageViewCreateFlagBits {
3171 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3172 f.write_str(
3173 match self {
3174 &Self::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT => {
3175 "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT"
3176 }
3177 &Self::FRAGMENT_DENSITY_MAP_DEFERRED_EXT => {
3178 "FRAGMENT_DENSITY_MAP_DEFERRED_EXT"
3179 }
3180 _ => "(unknown variant)",
3181 },
3182 )
3183 }
3184}
3185#[doc(alias = "VkImageViewType")]
3187#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3188#[repr(transparent)]
3189pub struct ImageViewType(pub i32);
3190impl std::fmt::Debug for ImageViewType {
3191 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3192 f.write_str(
3193 match self {
3194 &Self::_1D => "1D",
3195 &Self::_2D => "2D",
3196 &Self::_3D => "3D",
3197 &Self::CUBE => "CUBE",
3198 &Self::_1D_ARRAY => "1D_ARRAY",
3199 &Self::_2D_ARRAY => "2D_ARRAY",
3200 &Self::CUBE_ARRAY => "CUBE_ARRAY",
3201 _ => "(unknown variant)",
3202 },
3203 )
3204 }
3205}
3206impl crate::vk1_0::ImageViewType {
3208 pub const _1D: Self = Self(0);
3209 pub const _2D: Self = Self(1);
3210 pub const _3D: Self = Self(2);
3211 pub const CUBE: Self = Self(3);
3212 pub const _1D_ARRAY: Self = Self(4);
3213 pub const _2D_ARRAY: Self = Self(5);
3214 pub const CUBE_ARRAY: Self = Self(6);
3215}
3216#[doc(alias = "VkSharingMode")]
3218#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3219#[repr(transparent)]
3220pub struct SharingMode(pub i32);
3221impl std::fmt::Debug for SharingMode {
3222 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3223 f.write_str(
3224 match self {
3225 &Self::EXCLUSIVE => "EXCLUSIVE",
3226 &Self::CONCURRENT => "CONCURRENT",
3227 _ => "(unknown variant)",
3228 },
3229 )
3230 }
3231}
3232impl crate::vk1_0::SharingMode {
3234 pub const EXCLUSIVE: Self = Self(0);
3235 pub const CONCURRENT: Self = Self(1);
3236}
3237#[doc(alias = "VkIndexType")]
3239#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3240#[repr(transparent)]
3241pub struct IndexType(pub i32);
3242impl std::fmt::Debug for IndexType {
3243 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3244 f.write_str(
3245 match self {
3246 &Self::UINT16 => "UINT16",
3247 &Self::UINT32 => "UINT32",
3248 &Self::NONE_KHR => "NONE_KHR",
3249 &Self::UINT8_EXT => "UINT8_EXT",
3250 _ => "(unknown variant)",
3251 },
3252 )
3253 }
3254}
3255impl crate::vk1_0::IndexType {
3257 pub const UINT16: Self = Self(0);
3258 pub const UINT32: Self = Self(1);
3259}
3260#[doc(alias = "VkLogicOp")]
3262#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3263#[repr(transparent)]
3264pub struct LogicOp(pub i32);
3265impl std::fmt::Debug for LogicOp {
3266 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3267 f.write_str(
3268 match self {
3269 &Self::CLEAR => "CLEAR",
3270 &Self::AND => "AND",
3271 &Self::AND_REVERSE => "AND_REVERSE",
3272 &Self::COPY => "COPY",
3273 &Self::AND_INVERTED => "AND_INVERTED",
3274 &Self::NO_OP => "NO_OP",
3275 &Self::XOR => "XOR",
3276 &Self::OR => "OR",
3277 &Self::NOR => "NOR",
3278 &Self::EQUIVALENT => "EQUIVALENT",
3279 &Self::INVERT => "INVERT",
3280 &Self::OR_REVERSE => "OR_REVERSE",
3281 &Self::COPY_INVERTED => "COPY_INVERTED",
3282 &Self::OR_INVERTED => "OR_INVERTED",
3283 &Self::NAND => "NAND",
3284 &Self::SET => "SET",
3285 _ => "(unknown variant)",
3286 },
3287 )
3288 }
3289}
3290impl crate::vk1_0::LogicOp {
3292 pub const CLEAR: Self = Self(0);
3293 pub const AND: Self = Self(1);
3294 pub const AND_REVERSE: Self = Self(2);
3295 pub const COPY: Self = Self(3);
3296 pub const AND_INVERTED: Self = Self(4);
3297 pub const NO_OP: Self = Self(5);
3298 pub const XOR: Self = Self(6);
3299 pub const OR: Self = Self(7);
3300 pub const NOR: Self = Self(8);
3301 pub const EQUIVALENT: Self = Self(9);
3302 pub const INVERT: Self = Self(10);
3303 pub const OR_REVERSE: Self = Self(11);
3304 pub const COPY_INVERTED: Self = Self(12);
3305 pub const OR_INVERTED: Self = Self(13);
3306 pub const NAND: Self = Self(14);
3307 pub const SET: Self = Self(15);
3308}
3309bitflags::bitflags! {
3310 #[doc =
3311 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHeapFlags.html) · Bitmask of [`MemoryHeapFlagBits`]"]
3312 #[doc(alias = "VkMemoryHeapFlags")] #[derive(Default)] #[repr(transparent)] pub
3313 struct MemoryHeapFlags : u32 { const DEVICE_LOCAL = MemoryHeapFlagBits::DEVICE_LOCAL
3314 .0; const MULTI_INSTANCE = MemoryHeapFlagBits::MULTI_INSTANCE.0; const
3315 MULTI_INSTANCE_KHR = MemoryHeapFlagBits::MULTI_INSTANCE_KHR.0; }
3316}
3317#[doc(alias = "VkMemoryHeapFlagBits")]
3319#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3320#[repr(transparent)]
3321pub struct MemoryHeapFlagBits(pub u32);
3322impl MemoryHeapFlagBits {
3323 #[inline]
3324 pub const fn bitmask(&self) -> MemoryHeapFlags {
3326 MemoryHeapFlags::from_bits_truncate(self.0)
3327 }
3328}
3329impl std::fmt::Debug for MemoryHeapFlagBits {
3330 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3331 f.write_str(
3332 match self {
3333 &Self::DEVICE_LOCAL => "DEVICE_LOCAL",
3334 &Self::MULTI_INSTANCE => "MULTI_INSTANCE",
3335 _ => "(unknown variant)",
3336 },
3337 )
3338 }
3339}
3340impl crate::vk1_0::MemoryHeapFlagBits {
3342 pub const DEVICE_LOCAL: Self = Self(1);
3343}
3344bitflags::bitflags! {
3345 #[doc =
3346 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccessFlags.html) · Bitmask of [`AccessFlagBits`]"]
3347 #[doc(alias = "VkAccessFlags")] #[derive(Default)] #[repr(transparent)] pub struct
3348 AccessFlags : u32 { const INDIRECT_COMMAND_READ =
3349 AccessFlagBits::INDIRECT_COMMAND_READ.0; const INDEX_READ =
3350 AccessFlagBits::INDEX_READ.0; const VERTEX_ATTRIBUTE_READ =
3351 AccessFlagBits::VERTEX_ATTRIBUTE_READ.0; const UNIFORM_READ =
3352 AccessFlagBits::UNIFORM_READ.0; const INPUT_ATTACHMENT_READ =
3353 AccessFlagBits::INPUT_ATTACHMENT_READ.0; const SHADER_READ =
3354 AccessFlagBits::SHADER_READ.0; const SHADER_WRITE = AccessFlagBits::SHADER_WRITE.0;
3355 const COLOR_ATTACHMENT_READ = AccessFlagBits::COLOR_ATTACHMENT_READ.0; const
3356 COLOR_ATTACHMENT_WRITE = AccessFlagBits::COLOR_ATTACHMENT_WRITE.0; const
3357 DEPTH_STENCIL_ATTACHMENT_READ = AccessFlagBits::DEPTH_STENCIL_ATTACHMENT_READ.0;
3358 const DEPTH_STENCIL_ATTACHMENT_WRITE = AccessFlagBits::DEPTH_STENCIL_ATTACHMENT_WRITE
3359 .0; const TRANSFER_READ = AccessFlagBits::TRANSFER_READ.0; const TRANSFER_WRITE =
3360 AccessFlagBits::TRANSFER_WRITE.0; const HOST_READ = AccessFlagBits::HOST_READ.0;
3361 const HOST_WRITE = AccessFlagBits::HOST_WRITE.0; const MEMORY_READ =
3362 AccessFlagBits::MEMORY_READ.0; const MEMORY_WRITE = AccessFlagBits::MEMORY_WRITE.0;
3363 const NONE = AccessFlagBits::NONE.0; const TRANSFORM_FEEDBACK_WRITE_EXT =
3364 AccessFlagBits::TRANSFORM_FEEDBACK_WRITE_EXT.0; const
3365 TRANSFORM_FEEDBACK_COUNTER_READ_EXT =
3366 AccessFlagBits::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0; const
3367 TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT =
3368 AccessFlagBits::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0; const
3369 CONDITIONAL_RENDERING_READ_EXT = AccessFlagBits::CONDITIONAL_RENDERING_READ_EXT.0;
3370 const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT =
3371 AccessFlagBits::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0; const
3372 ACCELERATION_STRUCTURE_READ_KHR = AccessFlagBits::ACCELERATION_STRUCTURE_READ_KHR.0;
3373 const ACCELERATION_STRUCTURE_WRITE_KHR =
3374 AccessFlagBits::ACCELERATION_STRUCTURE_WRITE_KHR.0; const
3375 FRAGMENT_DENSITY_MAP_READ_EXT = AccessFlagBits::FRAGMENT_DENSITY_MAP_READ_EXT.0;
3376 const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR =
3377 AccessFlagBits::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0; const
3378 COMMAND_PREPROCESS_READ_NV = AccessFlagBits::COMMAND_PREPROCESS_READ_NV.0; const
3379 COMMAND_PREPROCESS_WRITE_NV = AccessFlagBits::COMMAND_PREPROCESS_WRITE_NV.0; const
3380 SHADING_RATE_IMAGE_READ_NV = AccessFlagBits::SHADING_RATE_IMAGE_READ_NV.0; const
3381 ACCELERATION_STRUCTURE_READ_NV = AccessFlagBits::ACCELERATION_STRUCTURE_READ_NV.0;
3382 const ACCELERATION_STRUCTURE_WRITE_NV =
3383 AccessFlagBits::ACCELERATION_STRUCTURE_WRITE_NV.0; const NONE_KHR =
3384 AccessFlagBits::NONE_KHR.0; }
3385}
3386#[doc(alias = "VkAccessFlagBits")]
3388#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3389#[repr(transparent)]
3390pub struct AccessFlagBits(pub u32);
3391impl AccessFlagBits {
3392 #[inline]
3393 pub const fn bitmask(&self) -> AccessFlags {
3395 AccessFlags::from_bits_truncate(self.0)
3396 }
3397}
3398impl std::fmt::Debug for AccessFlagBits {
3399 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3400 f.write_str(
3401 match self {
3402 &Self::INDIRECT_COMMAND_READ => "INDIRECT_COMMAND_READ",
3403 &Self::INDEX_READ => "INDEX_READ",
3404 &Self::VERTEX_ATTRIBUTE_READ => "VERTEX_ATTRIBUTE_READ",
3405 &Self::UNIFORM_READ => "UNIFORM_READ",
3406 &Self::INPUT_ATTACHMENT_READ => "INPUT_ATTACHMENT_READ",
3407 &Self::SHADER_READ => "SHADER_READ",
3408 &Self::SHADER_WRITE => "SHADER_WRITE",
3409 &Self::COLOR_ATTACHMENT_READ => "COLOR_ATTACHMENT_READ",
3410 &Self::COLOR_ATTACHMENT_WRITE => "COLOR_ATTACHMENT_WRITE",
3411 &Self::DEPTH_STENCIL_ATTACHMENT_READ => "DEPTH_STENCIL_ATTACHMENT_READ",
3412 &Self::DEPTH_STENCIL_ATTACHMENT_WRITE => "DEPTH_STENCIL_ATTACHMENT_WRITE",
3413 &Self::TRANSFER_READ => "TRANSFER_READ",
3414 &Self::TRANSFER_WRITE => "TRANSFER_WRITE",
3415 &Self::HOST_READ => "HOST_READ",
3416 &Self::HOST_WRITE => "HOST_WRITE",
3417 &Self::MEMORY_READ => "MEMORY_READ",
3418 &Self::MEMORY_WRITE => "MEMORY_WRITE",
3419 &Self::NONE => "NONE",
3420 &Self::TRANSFORM_FEEDBACK_WRITE_EXT => "TRANSFORM_FEEDBACK_WRITE_EXT",
3421 &Self::TRANSFORM_FEEDBACK_COUNTER_READ_EXT => {
3422 "TRANSFORM_FEEDBACK_COUNTER_READ_EXT"
3423 }
3424 &Self::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT => {
3425 "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT"
3426 }
3427 &Self::CONDITIONAL_RENDERING_READ_EXT => "CONDITIONAL_RENDERING_READ_EXT",
3428 &Self::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT => {
3429 "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT"
3430 }
3431 &Self::ACCELERATION_STRUCTURE_READ_KHR => {
3432 "ACCELERATION_STRUCTURE_READ_KHR"
3433 }
3434 &Self::ACCELERATION_STRUCTURE_WRITE_KHR => {
3435 "ACCELERATION_STRUCTURE_WRITE_KHR"
3436 }
3437 &Self::FRAGMENT_DENSITY_MAP_READ_EXT => "FRAGMENT_DENSITY_MAP_READ_EXT",
3438 &Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR => {
3439 "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR"
3440 }
3441 &Self::COMMAND_PREPROCESS_READ_NV => "COMMAND_PREPROCESS_READ_NV",
3442 &Self::COMMAND_PREPROCESS_WRITE_NV => "COMMAND_PREPROCESS_WRITE_NV",
3443 _ => "(unknown variant)",
3444 },
3445 )
3446 }
3447}
3448impl crate::vk1_0::AccessFlagBits {
3450 pub const INDIRECT_COMMAND_READ: Self = Self(1);
3451 pub const INDEX_READ: Self = Self(2);
3452 pub const VERTEX_ATTRIBUTE_READ: Self = Self(4);
3453 pub const UNIFORM_READ: Self = Self(8);
3454 pub const INPUT_ATTACHMENT_READ: Self = Self(16);
3455 pub const SHADER_READ: Self = Self(32);
3456 pub const SHADER_WRITE: Self = Self(64);
3457 pub const COLOR_ATTACHMENT_READ: Self = Self(128);
3458 pub const COLOR_ATTACHMENT_WRITE: Self = Self(256);
3459 pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(512);
3460 pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(1024);
3461 pub const TRANSFER_READ: Self = Self(2048);
3462 pub const TRANSFER_WRITE: Self = Self(4096);
3463 pub const HOST_READ: Self = Self(8192);
3464 pub const HOST_WRITE: Self = Self(16384);
3465 pub const MEMORY_READ: Self = Self(32768);
3466 pub const MEMORY_WRITE: Self = Self(65536);
3467}
3468bitflags::bitflags! {
3469 #[doc =
3470 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryPropertyFlags.html) · Bitmask of [`MemoryPropertyFlagBits`]"]
3471 #[doc(alias = "VkMemoryPropertyFlags")] #[derive(Default)] #[repr(transparent)] pub
3472 struct MemoryPropertyFlags : u32 { const DEVICE_LOCAL =
3473 MemoryPropertyFlagBits::DEVICE_LOCAL.0; const HOST_VISIBLE =
3474 MemoryPropertyFlagBits::HOST_VISIBLE.0; const HOST_COHERENT =
3475 MemoryPropertyFlagBits::HOST_COHERENT.0; const HOST_CACHED =
3476 MemoryPropertyFlagBits::HOST_CACHED.0; const LAZILY_ALLOCATED =
3477 MemoryPropertyFlagBits::LAZILY_ALLOCATED.0; const PROTECTED =
3478 MemoryPropertyFlagBits::PROTECTED.0; const DEVICE_COHERENT_AMD =
3479 MemoryPropertyFlagBits::DEVICE_COHERENT_AMD.0; const DEVICE_UNCACHED_AMD =
3480 MemoryPropertyFlagBits::DEVICE_UNCACHED_AMD.0; const RDMA_CAPABLE_NV =
3481 MemoryPropertyFlagBits::RDMA_CAPABLE_NV.0; }
3482}
3483#[doc(alias = "VkMemoryPropertyFlagBits")]
3485#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3486#[repr(transparent)]
3487pub struct MemoryPropertyFlagBits(pub u32);
3488impl MemoryPropertyFlagBits {
3489 #[inline]
3490 pub const fn bitmask(&self) -> MemoryPropertyFlags {
3492 MemoryPropertyFlags::from_bits_truncate(self.0)
3493 }
3494}
3495impl std::fmt::Debug for MemoryPropertyFlagBits {
3496 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3497 f.write_str(
3498 match self {
3499 &Self::DEVICE_LOCAL => "DEVICE_LOCAL",
3500 &Self::HOST_VISIBLE => "HOST_VISIBLE",
3501 &Self::HOST_COHERENT => "HOST_COHERENT",
3502 &Self::HOST_CACHED => "HOST_CACHED",
3503 &Self::LAZILY_ALLOCATED => "LAZILY_ALLOCATED",
3504 &Self::PROTECTED => "PROTECTED",
3505 &Self::DEVICE_COHERENT_AMD => "DEVICE_COHERENT_AMD",
3506 &Self::DEVICE_UNCACHED_AMD => "DEVICE_UNCACHED_AMD",
3507 &Self::RDMA_CAPABLE_NV => "RDMA_CAPABLE_NV",
3508 _ => "(unknown variant)",
3509 },
3510 )
3511 }
3512}
3513impl crate::vk1_0::MemoryPropertyFlagBits {
3515 pub const DEVICE_LOCAL: Self = Self(1);
3516 pub const HOST_VISIBLE: Self = Self(2);
3517 pub const HOST_COHERENT: Self = Self(4);
3518 pub const HOST_CACHED: Self = Self(8);
3519 pub const LAZILY_ALLOCATED: Self = Self(16);
3520}
3521#[doc(alias = "VkPhysicalDeviceType")]
3523#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3524#[repr(transparent)]
3525pub struct PhysicalDeviceType(pub i32);
3526impl std::fmt::Debug for PhysicalDeviceType {
3527 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3528 f.write_str(
3529 match self {
3530 &Self::OTHER => "OTHER",
3531 &Self::INTEGRATED_GPU => "INTEGRATED_GPU",
3532 &Self::DISCRETE_GPU => "DISCRETE_GPU",
3533 &Self::VIRTUAL_GPU => "VIRTUAL_GPU",
3534 &Self::CPU => "CPU",
3535 _ => "(unknown variant)",
3536 },
3537 )
3538 }
3539}
3540impl crate::vk1_0::PhysicalDeviceType {
3542 pub const OTHER: Self = Self(0);
3543 pub const INTEGRATED_GPU: Self = Self(1);
3544 pub const DISCRETE_GPU: Self = Self(2);
3545 pub const VIRTUAL_GPU: Self = Self(3);
3546 pub const CPU: Self = Self(4);
3547}
3548#[doc(alias = "VkPipelineBindPoint")]
3550#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3551#[repr(transparent)]
3552pub struct PipelineBindPoint(pub i32);
3553impl std::fmt::Debug for PipelineBindPoint {
3554 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3555 f.write_str(
3556 match self {
3557 &Self::GRAPHICS => "GRAPHICS",
3558 &Self::COMPUTE => "COMPUTE",
3559 &Self::RAY_TRACING_KHR => "RAY_TRACING_KHR",
3560 &Self::SUBPASS_SHADING_HUAWEI => "SUBPASS_SHADING_HUAWEI",
3561 _ => "(unknown variant)",
3562 },
3563 )
3564 }
3565}
3566impl crate::vk1_0::PipelineBindPoint {
3568 pub const GRAPHICS: Self = Self(0);
3569 pub const COMPUTE: Self = Self(1);
3570}
3571bitflags::bitflags! {
3572 #[doc =
3573 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreateFlags.html) · Bitmask of [`PipelineCreateFlagBits`]"]
3574 #[doc(alias = "VkPipelineCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
3575 struct PipelineCreateFlags : u32 { const DISABLE_OPTIMIZATION =
3576 PipelineCreateFlagBits::DISABLE_OPTIMIZATION.0; const ALLOW_DERIVATIVES =
3577 PipelineCreateFlagBits::ALLOW_DERIVATIVES.0; const DERIVATIVE =
3578 PipelineCreateFlagBits::DERIVATIVE.0; const VIEW_INDEX_FROM_DEVICE_INDEX =
3579 PipelineCreateFlagBits::VIEW_INDEX_FROM_DEVICE_INDEX.0; const DISPATCH_BASE =
3580 PipelineCreateFlagBits::DISPATCH_BASE.0; const FAIL_ON_PIPELINE_COMPILE_REQUIRED =
3581 PipelineCreateFlagBits::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0; const
3582 EARLY_RETURN_ON_FAILURE = PipelineCreateFlagBits::EARLY_RETURN_ON_FAILURE.0; const
3583 RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR =
3584 PipelineCreateFlagBits::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0; const
3585 RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT =
3586 PipelineCreateFlagBits::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0; const
3587 RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR =
3588 PipelineCreateFlagBits::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0; const
3589 RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR =
3590 PipelineCreateFlagBits::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR.0; const
3591 RAY_TRACING_NO_NULL_MISS_SHADERS_KHR =
3592 PipelineCreateFlagBits::RAY_TRACING_NO_NULL_MISS_SHADERS_KHR.0; const
3593 RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR =
3594 PipelineCreateFlagBits::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR.0; const
3595 RAY_TRACING_SKIP_TRIANGLES_KHR =
3596 PipelineCreateFlagBits::RAY_TRACING_SKIP_TRIANGLES_KHR.0; const
3597 RAY_TRACING_SKIP_AABBS_KHR = PipelineCreateFlagBits::RAY_TRACING_SKIP_AABBS_KHR.0;
3598 const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR =
3599 PipelineCreateFlagBits::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR.0; const
3600 DEFER_COMPILE_NV = PipelineCreateFlagBits::DEFER_COMPILE_NV.0; const
3601 CAPTURE_STATISTICS_KHR = PipelineCreateFlagBits::CAPTURE_STATISTICS_KHR.0; const
3602 CAPTURE_INTERNAL_REPRESENTATIONS_KHR =
3603 PipelineCreateFlagBits::CAPTURE_INTERNAL_REPRESENTATIONS_KHR.0; const
3604 INDIRECT_BINDABLE_NV = PipelineCreateFlagBits::INDIRECT_BINDABLE_NV.0; const
3605 LIBRARY_KHR = PipelineCreateFlagBits::LIBRARY_KHR.0; const
3606 RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT =
3607 PipelineCreateFlagBits::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT.0; const
3608 LINK_TIME_OPTIMIZATION_EXT = PipelineCreateFlagBits::LINK_TIME_OPTIMIZATION_EXT.0;
3609 const RAY_TRACING_ALLOW_MOTION_NV =
3610 PipelineCreateFlagBits::RAY_TRACING_ALLOW_MOTION_NV.0; #[allow(deprecated)]
3611 #[deprecated] const
3612 PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR =
3613 PipelineCreateFlagBits::PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR
3614 .0; #[allow(deprecated)] #[deprecated] const
3615 PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT =
3616 PipelineCreateFlagBits::PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT
3617 .0; const VIEW_INDEX_FROM_DEVICE_INDEX_KHR =
3618 PipelineCreateFlagBits::VIEW_INDEX_FROM_DEVICE_INDEX_KHR.0; const DISPATCH_BASE_KHR =
3619 PipelineCreateFlagBits::DISPATCH_BASE_KHR.0; const
3620 FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT =
3621 PipelineCreateFlagBits::FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT.0; const
3622 EARLY_RETURN_ON_FAILURE_EXT = PipelineCreateFlagBits::EARLY_RETURN_ON_FAILURE_EXT.0;
3623 }
3624}
3625#[doc(alias = "VkPipelineCreateFlagBits")]
3627#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3628#[repr(transparent)]
3629pub struct PipelineCreateFlagBits(pub u32);
3630impl PipelineCreateFlagBits {
3631 #[inline]
3632 pub const fn bitmask(&self) -> PipelineCreateFlags {
3634 PipelineCreateFlags::from_bits_truncate(self.0)
3635 }
3636}
3637impl std::fmt::Debug for PipelineCreateFlagBits {
3638 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3639 f.write_str(
3640 match self {
3641 &Self::DISABLE_OPTIMIZATION => "DISABLE_OPTIMIZATION",
3642 &Self::ALLOW_DERIVATIVES => "ALLOW_DERIVATIVES",
3643 &Self::DERIVATIVE => "DERIVATIVE",
3644 &Self::VIEW_INDEX_FROM_DEVICE_INDEX => "VIEW_INDEX_FROM_DEVICE_INDEX",
3645 &Self::DISPATCH_BASE => "DISPATCH_BASE",
3646 &Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED => {
3647 "FAIL_ON_PIPELINE_COMPILE_REQUIRED"
3648 }
3649 &Self::EARLY_RETURN_ON_FAILURE => "EARLY_RETURN_ON_FAILURE",
3650 &Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR => {
3651 "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR"
3652 }
3653 &Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT => {
3654 "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT"
3655 }
3656 &Self::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR => {
3657 "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR"
3658 }
3659 &Self::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR => {
3660 "RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR"
3661 }
3662 &Self::RAY_TRACING_NO_NULL_MISS_SHADERS_KHR => {
3663 "RAY_TRACING_NO_NULL_MISS_SHADERS_KHR"
3664 }
3665 &Self::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR => {
3666 "RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR"
3667 }
3668 &Self::RAY_TRACING_SKIP_TRIANGLES_KHR => "RAY_TRACING_SKIP_TRIANGLES_KHR",
3669 &Self::RAY_TRACING_SKIP_AABBS_KHR => "RAY_TRACING_SKIP_AABBS_KHR",
3670 &Self::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR => {
3671 "RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR"
3672 }
3673 &Self::DEFER_COMPILE_NV => "DEFER_COMPILE_NV",
3674 &Self::CAPTURE_STATISTICS_KHR => "CAPTURE_STATISTICS_KHR",
3675 &Self::CAPTURE_INTERNAL_REPRESENTATIONS_KHR => {
3676 "CAPTURE_INTERNAL_REPRESENTATIONS_KHR"
3677 }
3678 &Self::INDIRECT_BINDABLE_NV => "INDIRECT_BINDABLE_NV",
3679 &Self::LIBRARY_KHR => "LIBRARY_KHR",
3680 &Self::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT => {
3681 "RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT"
3682 }
3683 &Self::LINK_TIME_OPTIMIZATION_EXT => "LINK_TIME_OPTIMIZATION_EXT",
3684 &Self::RAY_TRACING_ALLOW_MOTION_NV => "RAY_TRACING_ALLOW_MOTION_NV",
3685 _ => "(unknown variant)",
3686 },
3687 )
3688 }
3689}
3690impl crate::vk1_0::PipelineCreateFlagBits {
3692 pub const DISABLE_OPTIMIZATION: Self = Self(1);
3693 pub const ALLOW_DERIVATIVES: Self = Self(2);
3694 pub const DERIVATIVE: Self = Self(4);
3695}
3696#[doc(alias = "VkPrimitiveTopology")]
3698#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3699#[repr(transparent)]
3700pub struct PrimitiveTopology(pub i32);
3701impl std::fmt::Debug for PrimitiveTopology {
3702 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3703 f.write_str(
3704 match self {
3705 &Self::POINT_LIST => "POINT_LIST",
3706 &Self::LINE_LIST => "LINE_LIST",
3707 &Self::LINE_STRIP => "LINE_STRIP",
3708 &Self::TRIANGLE_LIST => "TRIANGLE_LIST",
3709 &Self::TRIANGLE_STRIP => "TRIANGLE_STRIP",
3710 &Self::TRIANGLE_FAN => "TRIANGLE_FAN",
3711 &Self::LINE_LIST_WITH_ADJACENCY => "LINE_LIST_WITH_ADJACENCY",
3712 &Self::LINE_STRIP_WITH_ADJACENCY => "LINE_STRIP_WITH_ADJACENCY",
3713 &Self::TRIANGLE_LIST_WITH_ADJACENCY => "TRIANGLE_LIST_WITH_ADJACENCY",
3714 &Self::TRIANGLE_STRIP_WITH_ADJACENCY => "TRIANGLE_STRIP_WITH_ADJACENCY",
3715 &Self::PATCH_LIST => "PATCH_LIST",
3716 _ => "(unknown variant)",
3717 },
3718 )
3719 }
3720}
3721impl crate::vk1_0::PrimitiveTopology {
3723 pub const POINT_LIST: Self = Self(0);
3724 pub const LINE_LIST: Self = Self(1);
3725 pub const LINE_STRIP: Self = Self(2);
3726 pub const TRIANGLE_LIST: Self = Self(3);
3727 pub const TRIANGLE_STRIP: Self = Self(4);
3728 pub const TRIANGLE_FAN: Self = Self(5);
3729 pub const LINE_LIST_WITH_ADJACENCY: Self = Self(6);
3730 pub const LINE_STRIP_WITH_ADJACENCY: Self = Self(7);
3731 pub const TRIANGLE_LIST_WITH_ADJACENCY: Self = Self(8);
3732 pub const TRIANGLE_STRIP_WITH_ADJACENCY: Self = Self(9);
3733 pub const PATCH_LIST: Self = Self(10);
3734}
3735bitflags::bitflags! {
3736 #[doc =
3737 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryControlFlags.html) · Bitmask of [`QueryControlFlagBits`]"]
3738 #[doc(alias = "VkQueryControlFlags")] #[derive(Default)] #[repr(transparent)] pub
3739 struct QueryControlFlags : u32 { const PRECISE = QueryControlFlagBits::PRECISE.0; }
3740}
3741#[doc(alias = "VkQueryControlFlagBits")]
3743#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3744#[repr(transparent)]
3745pub struct QueryControlFlagBits(pub u32);
3746impl QueryControlFlagBits {
3747 #[inline]
3748 pub const fn bitmask(&self) -> QueryControlFlags {
3750 QueryControlFlags::from_bits_truncate(self.0)
3751 }
3752}
3753impl std::fmt::Debug for QueryControlFlagBits {
3754 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3755 f.write_str(
3756 match self {
3757 &Self::PRECISE => "PRECISE",
3758 _ => "(unknown variant)",
3759 },
3760 )
3761 }
3762}
3763impl crate::vk1_0::QueryControlFlagBits {
3765 pub const PRECISE: Self = Self(1);
3766}
3767bitflags::bitflags! {
3768 #[doc =
3769 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPipelineStatisticFlags.html) · Bitmask of [`QueryPipelineStatisticFlagBits`]"]
3770 #[doc(alias = "VkQueryPipelineStatisticFlags")] #[derive(Default)]
3771 #[repr(transparent)] pub struct QueryPipelineStatisticFlags : u32 { const
3772 INPUT_ASSEMBLY_VERTICES = QueryPipelineStatisticFlagBits::INPUT_ASSEMBLY_VERTICES.0;
3773 const INPUT_ASSEMBLY_PRIMITIVES =
3774 QueryPipelineStatisticFlagBits::INPUT_ASSEMBLY_PRIMITIVES.0; const
3775 VERTEX_SHADER_INVOCATIONS = QueryPipelineStatisticFlagBits::VERTEX_SHADER_INVOCATIONS
3776 .0; const GEOMETRY_SHADER_INVOCATIONS =
3777 QueryPipelineStatisticFlagBits::GEOMETRY_SHADER_INVOCATIONS.0; const
3778 GEOMETRY_SHADER_PRIMITIVES =
3779 QueryPipelineStatisticFlagBits::GEOMETRY_SHADER_PRIMITIVES.0; const
3780 CLIPPING_INVOCATIONS = QueryPipelineStatisticFlagBits::CLIPPING_INVOCATIONS.0; const
3781 CLIPPING_PRIMITIVES = QueryPipelineStatisticFlagBits::CLIPPING_PRIMITIVES.0; const
3782 FRAGMENT_SHADER_INVOCATIONS =
3783 QueryPipelineStatisticFlagBits::FRAGMENT_SHADER_INVOCATIONS.0; const
3784 TESSELLATION_CONTROL_SHADER_PATCHES =
3785 QueryPipelineStatisticFlagBits::TESSELLATION_CONTROL_SHADER_PATCHES.0; const
3786 TESSELLATION_EVALUATION_SHADER_INVOCATIONS =
3787 QueryPipelineStatisticFlagBits::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0; const
3788 COMPUTE_SHADER_INVOCATIONS =
3789 QueryPipelineStatisticFlagBits::COMPUTE_SHADER_INVOCATIONS.0; }
3790}
3791#[doc(alias = "VkQueryPipelineStatisticFlagBits")]
3793#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3794#[repr(transparent)]
3795pub struct QueryPipelineStatisticFlagBits(pub u32);
3796impl QueryPipelineStatisticFlagBits {
3797 #[inline]
3798 pub const fn bitmask(&self) -> QueryPipelineStatisticFlags {
3800 QueryPipelineStatisticFlags::from_bits_truncate(self.0)
3801 }
3802}
3803impl std::fmt::Debug for QueryPipelineStatisticFlagBits {
3804 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3805 f.write_str(
3806 match self {
3807 &Self::INPUT_ASSEMBLY_VERTICES => "INPUT_ASSEMBLY_VERTICES",
3808 &Self::INPUT_ASSEMBLY_PRIMITIVES => "INPUT_ASSEMBLY_PRIMITIVES",
3809 &Self::VERTEX_SHADER_INVOCATIONS => "VERTEX_SHADER_INVOCATIONS",
3810 &Self::GEOMETRY_SHADER_INVOCATIONS => "GEOMETRY_SHADER_INVOCATIONS",
3811 &Self::GEOMETRY_SHADER_PRIMITIVES => "GEOMETRY_SHADER_PRIMITIVES",
3812 &Self::CLIPPING_INVOCATIONS => "CLIPPING_INVOCATIONS",
3813 &Self::CLIPPING_PRIMITIVES => "CLIPPING_PRIMITIVES",
3814 &Self::FRAGMENT_SHADER_INVOCATIONS => "FRAGMENT_SHADER_INVOCATIONS",
3815 &Self::TESSELLATION_CONTROL_SHADER_PATCHES => {
3816 "TESSELLATION_CONTROL_SHADER_PATCHES"
3817 }
3818 &Self::TESSELLATION_EVALUATION_SHADER_INVOCATIONS => {
3819 "TESSELLATION_EVALUATION_SHADER_INVOCATIONS"
3820 }
3821 &Self::COMPUTE_SHADER_INVOCATIONS => "COMPUTE_SHADER_INVOCATIONS",
3822 _ => "(unknown variant)",
3823 },
3824 )
3825 }
3826}
3827impl crate::vk1_0::QueryPipelineStatisticFlagBits {
3829 pub const INPUT_ASSEMBLY_VERTICES: Self = Self(1);
3830 pub const INPUT_ASSEMBLY_PRIMITIVES: Self = Self(2);
3831 pub const VERTEX_SHADER_INVOCATIONS: Self = Self(4);
3832 pub const GEOMETRY_SHADER_INVOCATIONS: Self = Self(8);
3833 pub const GEOMETRY_SHADER_PRIMITIVES: Self = Self(16);
3834 pub const CLIPPING_INVOCATIONS: Self = Self(32);
3835 pub const CLIPPING_PRIMITIVES: Self = Self(64);
3836 pub const FRAGMENT_SHADER_INVOCATIONS: Self = Self(128);
3837 pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = Self(256);
3838 pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = Self(512);
3839 pub const COMPUTE_SHADER_INVOCATIONS: Self = Self(1024);
3840}
3841bitflags::bitflags! {
3842 #[doc =
3843 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryResultFlags.html) · Bitmask of [`QueryResultFlagBits`]"]
3844 #[doc(alias = "VkQueryResultFlags")] #[derive(Default)] #[repr(transparent)] pub
3845 struct QueryResultFlags : u32 { const _64 = QueryResultFlagBits::_64.0; const WAIT =
3846 QueryResultFlagBits::WAIT.0; const WITH_AVAILABILITY =
3847 QueryResultFlagBits::WITH_AVAILABILITY.0; const PARTIAL =
3848 QueryResultFlagBits::PARTIAL.0; const WITH_STATUS_KHR =
3849 QueryResultFlagBits::WITH_STATUS_KHR.0; }
3850}
3851#[doc(alias = "VkQueryResultFlagBits")]
3853#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3854#[repr(transparent)]
3855pub struct QueryResultFlagBits(pub u32);
3856impl QueryResultFlagBits {
3857 #[inline]
3858 pub const fn bitmask(&self) -> QueryResultFlags {
3860 QueryResultFlags::from_bits_truncate(self.0)
3861 }
3862}
3863impl std::fmt::Debug for QueryResultFlagBits {
3864 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3865 f.write_str(
3866 match self {
3867 &Self::_64 => "64",
3868 &Self::WAIT => "WAIT",
3869 &Self::WITH_AVAILABILITY => "WITH_AVAILABILITY",
3870 &Self::PARTIAL => "PARTIAL",
3871 &Self::WITH_STATUS_KHR => "WITH_STATUS_KHR",
3872 _ => "(unknown variant)",
3873 },
3874 )
3875 }
3876}
3877impl crate::vk1_0::QueryResultFlagBits {
3879 pub const _64: Self = Self(1);
3880 pub const WAIT: Self = Self(2);
3881 pub const WITH_AVAILABILITY: Self = Self(4);
3882 pub const PARTIAL: Self = Self(8);
3883}
3884#[doc(alias = "VkQueryType")]
3886#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3887#[repr(transparent)]
3888pub struct QueryType(pub i32);
3889impl std::fmt::Debug for QueryType {
3890 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3891 f.write_str(
3892 match self {
3893 &Self::OCCLUSION => "OCCLUSION",
3894 &Self::PIPELINE_STATISTICS => "PIPELINE_STATISTICS",
3895 &Self::TIMESTAMP => "TIMESTAMP",
3896 &Self::RESULT_STATUS_ONLY_KHR => "RESULT_STATUS_ONLY_KHR",
3897 &Self::TRANSFORM_FEEDBACK_STREAM_EXT => "TRANSFORM_FEEDBACK_STREAM_EXT",
3898 &Self::PERFORMANCE_QUERY_KHR => "PERFORMANCE_QUERY_KHR",
3899 &Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR => {
3900 "ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR"
3901 }
3902 &Self::ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR => {
3903 "ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR"
3904 }
3905 &Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => {
3906 "ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV"
3907 }
3908 &Self::PERFORMANCE_QUERY_INTEL => "PERFORMANCE_QUERY_INTEL",
3909 &Self::VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR => {
3910 "VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR"
3911 }
3912 &Self::PRIMITIVES_GENERATED_EXT => "PRIMITIVES_GENERATED_EXT",
3913 &Self::ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR => {
3914 "ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR"
3915 }
3916 &Self::ACCELERATION_STRUCTURE_SIZE_KHR => {
3917 "ACCELERATION_STRUCTURE_SIZE_KHR"
3918 }
3919 _ => "(unknown variant)",
3920 },
3921 )
3922 }
3923}
3924impl crate::vk1_0::QueryType {
3926 pub const OCCLUSION: Self = Self(0);
3927 pub const PIPELINE_STATISTICS: Self = Self(1);
3928 pub const TIMESTAMP: Self = Self(2);
3929}
3930bitflags::bitflags! {
3931 #[doc =
3932 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFlags.html) · Bitmask of [`QueueFlagBits`]"]
3933 #[doc(alias = "VkQueueFlags")] #[derive(Default)] #[repr(transparent)] pub struct
3934 QueueFlags : u32 { const GRAPHICS = QueueFlagBits::GRAPHICS.0; const COMPUTE =
3935 QueueFlagBits::COMPUTE.0; const TRANSFER = QueueFlagBits::TRANSFER.0; const
3936 SPARSE_BINDING = QueueFlagBits::SPARSE_BINDING.0; const PROTECTED =
3937 QueueFlagBits::PROTECTED.0; const VIDEO_DECODE_KHR = QueueFlagBits::VIDEO_DECODE_KHR
3938 .0; const VIDEO_ENCODE_KHR = QueueFlagBits::VIDEO_ENCODE_KHR.0; }
3939}
3940#[doc(alias = "VkQueueFlagBits")]
3942#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3943#[repr(transparent)]
3944pub struct QueueFlagBits(pub u32);
3945impl QueueFlagBits {
3946 #[inline]
3947 pub const fn bitmask(&self) -> QueueFlags {
3949 QueueFlags::from_bits_truncate(self.0)
3950 }
3951}
3952impl std::fmt::Debug for QueueFlagBits {
3953 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3954 f.write_str(
3955 match self {
3956 &Self::GRAPHICS => "GRAPHICS",
3957 &Self::COMPUTE => "COMPUTE",
3958 &Self::TRANSFER => "TRANSFER",
3959 &Self::SPARSE_BINDING => "SPARSE_BINDING",
3960 &Self::PROTECTED => "PROTECTED",
3961 &Self::VIDEO_DECODE_KHR => "VIDEO_DECODE_KHR",
3962 &Self::VIDEO_ENCODE_KHR => "VIDEO_ENCODE_KHR",
3963 _ => "(unknown variant)",
3964 },
3965 )
3966 }
3967}
3968impl crate::vk1_0::QueueFlagBits {
3970 pub const GRAPHICS: Self = Self(1);
3971 pub const COMPUTE: Self = Self(2);
3972 pub const TRANSFER: Self = Self(4);
3973 pub const SPARSE_BINDING: Self = Self(8);
3974}
3975#[doc(alias = "VkSubpassContents")]
3977#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3978#[repr(transparent)]
3979pub struct SubpassContents(pub i32);
3980impl std::fmt::Debug for SubpassContents {
3981 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3982 f.write_str(
3983 match self {
3984 &Self::INLINE => "INLINE",
3985 &Self::SECONDARY_COMMAND_BUFFERS => "SECONDARY_COMMAND_BUFFERS",
3986 _ => "(unknown variant)",
3987 },
3988 )
3989 }
3990}
3991impl crate::vk1_0::SubpassContents {
3993 pub const INLINE: Self = Self(0);
3994 pub const SECONDARY_COMMAND_BUFFERS: Self = Self(1);
3995}
3996#[doc(alias = "VkResult")]
3998#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
3999#[repr(transparent)]
4000pub struct Result(pub i32);
4001impl std::fmt::Debug for Result {
4002 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4003 f.write_str(
4004 match self {
4005 &Self::SUCCESS => "SUCCESS",
4006 &Self::NOT_READY => "NOT_READY",
4007 &Self::TIMEOUT => "TIMEOUT",
4008 &Self::EVENT_SET => "EVENT_SET",
4009 &Self::EVENT_RESET => "EVENT_RESET",
4010 &Self::INCOMPLETE => "INCOMPLETE",
4011 &Self::ERROR_OUT_OF_HOST_MEMORY => "ERROR_OUT_OF_HOST_MEMORY",
4012 &Self::ERROR_OUT_OF_DEVICE_MEMORY => "ERROR_OUT_OF_DEVICE_MEMORY",
4013 &Self::ERROR_INITIALIZATION_FAILED => "ERROR_INITIALIZATION_FAILED",
4014 &Self::ERROR_DEVICE_LOST => "ERROR_DEVICE_LOST",
4015 &Self::ERROR_MEMORY_MAP_FAILED => "ERROR_MEMORY_MAP_FAILED",
4016 &Self::ERROR_LAYER_NOT_PRESENT => "ERROR_LAYER_NOT_PRESENT",
4017 &Self::ERROR_EXTENSION_NOT_PRESENT => "ERROR_EXTENSION_NOT_PRESENT",
4018 &Self::ERROR_FEATURE_NOT_PRESENT => "ERROR_FEATURE_NOT_PRESENT",
4019 &Self::ERROR_INCOMPATIBLE_DRIVER => "ERROR_INCOMPATIBLE_DRIVER",
4020 &Self::ERROR_TOO_MANY_OBJECTS => "ERROR_TOO_MANY_OBJECTS",
4021 &Self::ERROR_FORMAT_NOT_SUPPORTED => "ERROR_FORMAT_NOT_SUPPORTED",
4022 &Self::ERROR_FRAGMENTED_POOL => "ERROR_FRAGMENTED_POOL",
4023 &Self::ERROR_UNKNOWN => "ERROR_UNKNOWN",
4024 &Self::ERROR_OUT_OF_POOL_MEMORY => "ERROR_OUT_OF_POOL_MEMORY",
4025 &Self::ERROR_INVALID_EXTERNAL_HANDLE => "ERROR_INVALID_EXTERNAL_HANDLE",
4026 &Self::ERROR_FRAGMENTATION => "ERROR_FRAGMENTATION",
4027 &Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS => {
4028 "ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"
4029 }
4030 &Self::PIPELINE_COMPILE_REQUIRED => "PIPELINE_COMPILE_REQUIRED",
4031 &Self::ERROR_SURFACE_LOST_KHR => "ERROR_SURFACE_LOST_KHR",
4032 &Self::ERROR_NATIVE_WINDOW_IN_USE_KHR => "ERROR_NATIVE_WINDOW_IN_USE_KHR",
4033 &Self::SUBOPTIMAL_KHR => "SUBOPTIMAL_KHR",
4034 &Self::ERROR_OUT_OF_DATE_KHR => "ERROR_OUT_OF_DATE_KHR",
4035 &Self::ERROR_INCOMPATIBLE_DISPLAY_KHR => "ERROR_INCOMPATIBLE_DISPLAY_KHR",
4036 &Self::ERROR_VALIDATION_FAILED_EXT => "ERROR_VALIDATION_FAILED_EXT",
4037 &Self::ERROR_INVALID_SHADER_NV => "ERROR_INVALID_SHADER_NV",
4038 &Self::ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT => {
4039 "ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"
4040 }
4041 &Self::ERROR_NOT_PERMITTED_KHR => "ERROR_NOT_PERMITTED_KHR",
4042 &Self::ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT => {
4043 "ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"
4044 }
4045 &Self::THREAD_IDLE_KHR => "THREAD_IDLE_KHR",
4046 &Self::THREAD_DONE_KHR => "THREAD_DONE_KHR",
4047 &Self::OPERATION_DEFERRED_KHR => "OPERATION_DEFERRED_KHR",
4048 &Self::OPERATION_NOT_DEFERRED_KHR => "OPERATION_NOT_DEFERRED_KHR",
4049 &Self::ERROR_COMPRESSION_EXHAUSTED_EXT => {
4050 "ERROR_COMPRESSION_EXHAUSTED_EXT"
4051 }
4052 _ => "(unknown variant)",
4053 },
4054 )
4055 }
4056}
4057impl crate::vk1_0::Result {
4059 pub const SUCCESS: Self = Self(0);
4060 pub const NOT_READY: Self = Self(1);
4061 pub const TIMEOUT: Self = Self(2);
4062 pub const EVENT_SET: Self = Self(3);
4063 pub const EVENT_RESET: Self = Self(4);
4064 pub const INCOMPLETE: Self = Self(5);
4065 pub const ERROR_OUT_OF_HOST_MEMORY: Self = Self(-1);
4066 pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Self(-2);
4067 pub const ERROR_INITIALIZATION_FAILED: Self = Self(-3);
4068 pub const ERROR_DEVICE_LOST: Self = Self(-4);
4069 pub const ERROR_MEMORY_MAP_FAILED: Self = Self(-5);
4070 pub const ERROR_LAYER_NOT_PRESENT: Self = Self(-6);
4071 pub const ERROR_EXTENSION_NOT_PRESENT: Self = Self(-7);
4072 pub const ERROR_FEATURE_NOT_PRESENT: Self = Self(-8);
4073 pub const ERROR_INCOMPATIBLE_DRIVER: Self = Self(-9);
4074 pub const ERROR_TOO_MANY_OBJECTS: Self = Self(-10);
4075 pub const ERROR_FORMAT_NOT_SUPPORTED: Self = Self(-11);
4076 pub const ERROR_FRAGMENTED_POOL: Self = Self(-12);
4077 pub const ERROR_UNKNOWN: Self = Self(-13);
4078}
4079bitflags::bitflags! {
4080 #[doc =
4081 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderStageFlags.html) · Bitmask of [`ShaderStageFlagBits`]"]
4082 #[doc(alias = "VkShaderStageFlags")] #[derive(Default)] #[repr(transparent)] pub
4083 struct ShaderStageFlags : u32 { const VERTEX = ShaderStageFlagBits::VERTEX.0; const
4084 TESSELLATION_CONTROL = ShaderStageFlagBits::TESSELLATION_CONTROL.0; const
4085 TESSELLATION_EVALUATION = ShaderStageFlagBits::TESSELLATION_EVALUATION.0; const
4086 GEOMETRY = ShaderStageFlagBits::GEOMETRY.0; const FRAGMENT =
4087 ShaderStageFlagBits::FRAGMENT.0; const COMPUTE = ShaderStageFlagBits::COMPUTE.0;
4088 const ALL_GRAPHICS = ShaderStageFlagBits::ALL_GRAPHICS.0; const ALL =
4089 ShaderStageFlagBits::ALL.0; const RAYGEN_KHR = ShaderStageFlagBits::RAYGEN_KHR.0;
4090 const ANY_HIT_KHR = ShaderStageFlagBits::ANY_HIT_KHR.0; const CLOSEST_HIT_KHR =
4091 ShaderStageFlagBits::CLOSEST_HIT_KHR.0; const MISS_KHR =
4092 ShaderStageFlagBits::MISS_KHR.0; const INTERSECTION_KHR =
4093 ShaderStageFlagBits::INTERSECTION_KHR.0; const CALLABLE_KHR =
4094 ShaderStageFlagBits::CALLABLE_KHR.0; const TASK_NV = ShaderStageFlagBits::TASK_NV.0;
4095 const MESH_NV = ShaderStageFlagBits::MESH_NV.0; const SUBPASS_SHADING_HUAWEI =
4096 ShaderStageFlagBits::SUBPASS_SHADING_HUAWEI.0; const RAYGEN_NV =
4097 ShaderStageFlagBits::RAYGEN_NV.0; const ANY_HIT_NV = ShaderStageFlagBits::ANY_HIT_NV
4098 .0; const CLOSEST_HIT_NV = ShaderStageFlagBits::CLOSEST_HIT_NV.0; const MISS_NV =
4099 ShaderStageFlagBits::MISS_NV.0; const INTERSECTION_NV =
4100 ShaderStageFlagBits::INTERSECTION_NV.0; const CALLABLE_NV =
4101 ShaderStageFlagBits::CALLABLE_NV.0; }
4102}
4103#[doc(alias = "VkShaderStageFlagBits")]
4105#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
4106#[repr(transparent)]
4107pub struct ShaderStageFlagBits(pub u32);
4108impl ShaderStageFlagBits {
4109 #[inline]
4110 pub const fn bitmask(&self) -> ShaderStageFlags {
4112 ShaderStageFlags::from_bits_truncate(self.0)
4113 }
4114}
4115impl std::fmt::Debug for ShaderStageFlagBits {
4116 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4117 f.write_str(
4118 match self {
4119 &Self::VERTEX => "VERTEX",
4120 &Self::TESSELLATION_CONTROL => "TESSELLATION_CONTROL",
4121 &Self::TESSELLATION_EVALUATION => "TESSELLATION_EVALUATION",
4122 &Self::GEOMETRY => "GEOMETRY",
4123 &Self::FRAGMENT => "FRAGMENT",
4124 &Self::COMPUTE => "COMPUTE",
4125 &Self::ALL_GRAPHICS => "ALL_GRAPHICS",
4126 &Self::ALL => "ALL",
4127 &Self::RAYGEN_KHR => "RAYGEN_KHR",
4128 &Self::ANY_HIT_KHR => "ANY_HIT_KHR",
4129 &Self::CLOSEST_HIT_KHR => "CLOSEST_HIT_KHR",
4130 &Self::MISS_KHR => "MISS_KHR",
4131 &Self::INTERSECTION_KHR => "INTERSECTION_KHR",
4132 &Self::CALLABLE_KHR => "CALLABLE_KHR",
4133 &Self::TASK_NV => "TASK_NV",
4134 &Self::MESH_NV => "MESH_NV",
4135 &Self::SUBPASS_SHADING_HUAWEI => "SUBPASS_SHADING_HUAWEI",
4136 _ => "(unknown variant)",
4137 },
4138 )
4139 }
4140}
4141impl crate::vk1_0::ShaderStageFlagBits {
4143 pub const VERTEX: Self = Self(1);
4144 pub const TESSELLATION_CONTROL: Self = Self(2);
4145 pub const TESSELLATION_EVALUATION: Self = Self(4);
4146 pub const GEOMETRY: Self = Self(8);
4147 pub const FRAGMENT: Self = Self(16);
4148 pub const COMPUTE: Self = Self(32);
4149 pub const ALL_GRAPHICS: Self = Self(31);
4150 pub const ALL: Self = Self(2147483647);
4151}
4152bitflags::bitflags! {
4153 #[doc =
4154 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBindFlags.html) · Bitmask of [`SparseMemoryBindFlagBits`]"]
4155 #[doc(alias = "VkSparseMemoryBindFlags")] #[derive(Default)] #[repr(transparent)] pub
4156 struct SparseMemoryBindFlags : u32 { const METADATA =
4157 SparseMemoryBindFlagBits::METADATA.0; }
4158}
4159#[doc(alias = "VkSparseMemoryBindFlagBits")]
4161#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
4162#[repr(transparent)]
4163pub struct SparseMemoryBindFlagBits(pub u32);
4164impl SparseMemoryBindFlagBits {
4165 #[inline]
4166 pub const fn bitmask(&self) -> SparseMemoryBindFlags {
4168 SparseMemoryBindFlags::from_bits_truncate(self.0)
4169 }
4170}
4171impl std::fmt::Debug for SparseMemoryBindFlagBits {
4172 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4173 f.write_str(
4174 match self {
4175 &Self::METADATA => "METADATA",
4176 _ => "(unknown variant)",
4177 },
4178 )
4179 }
4180}
4181impl crate::vk1_0::SparseMemoryBindFlagBits {
4183 pub const METADATA: Self = Self(1);
4184}
4185bitflags::bitflags! {
4186 #[doc =
4187 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilFaceFlags.html) · Bitmask of [`StencilFaceFlagBits`]"]
4188 #[doc(alias = "VkStencilFaceFlags")] #[derive(Default)] #[repr(transparent)] pub
4189 struct StencilFaceFlags : u32 { const FRONT = StencilFaceFlagBits::FRONT.0; const
4190 BACK = StencilFaceFlagBits::BACK.0; const FRONT_AND_BACK =
4191 StencilFaceFlagBits::FRONT_AND_BACK.0; #[allow(deprecated)] #[deprecated] const
4192 STENCIL_FRONT_AND_BACK = StencilFaceFlagBits::STENCIL_FRONT_AND_BACK.0; }
4193}
4194#[doc(alias = "VkStencilFaceFlagBits")]
4196#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
4197#[repr(transparent)]
4198pub struct StencilFaceFlagBits(pub u32);
4199impl StencilFaceFlagBits {
4200 #[inline]
4201 pub const fn bitmask(&self) -> StencilFaceFlags {
4203 StencilFaceFlags::from_bits_truncate(self.0)
4204 }
4205}
4206impl std::fmt::Debug for StencilFaceFlagBits {
4207 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4208 f.write_str(
4209 match self {
4210 &Self::FRONT => "FRONT",
4211 &Self::BACK => "BACK",
4212 &Self::FRONT_AND_BACK => "FRONT_AND_BACK",
4213 _ => "(unknown variant)",
4214 },
4215 )
4216 }
4217}
4218impl crate::vk1_0::StencilFaceFlagBits {
4220 pub const FRONT: Self = Self(1);
4221 pub const BACK: Self = Self(2);
4222 pub const FRONT_AND_BACK: Self = Self(3);
4223 #[deprecated]
4224 pub const STENCIL_FRONT_AND_BACK: Self = Self::FRONT_AND_BACK;
4225}
4226#[doc(alias = "VkStencilOp")]
4228#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
4229#[repr(transparent)]
4230pub struct StencilOp(pub i32);
4231impl std::fmt::Debug for StencilOp {
4232 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4233 f.write_str(
4234 match self {
4235 &Self::KEEP => "KEEP",
4236 &Self::ZERO => "ZERO",
4237 &Self::REPLACE => "REPLACE",
4238 &Self::INCREMENT_AND_CLAMP => "INCREMENT_AND_CLAMP",
4239 &Self::DECREMENT_AND_CLAMP => "DECREMENT_AND_CLAMP",
4240 &Self::INVERT => "INVERT",
4241 &Self::INCREMENT_AND_WRAP => "INCREMENT_AND_WRAP",
4242 &Self::DECREMENT_AND_WRAP => "DECREMENT_AND_WRAP",
4243 _ => "(unknown variant)",
4244 },
4245 )
4246 }
4247}
4248impl crate::vk1_0::StencilOp {
4250 pub const KEEP: Self = Self(0);
4251 pub const ZERO: Self = Self(1);
4252 pub const REPLACE: Self = Self(2);
4253 pub const INCREMENT_AND_CLAMP: Self = Self(3);
4254 pub const DECREMENT_AND_CLAMP: Self = Self(4);
4255 pub const INVERT: Self = Self(5);
4256 pub const INCREMENT_AND_WRAP: Self = Self(6);
4257 pub const DECREMENT_AND_WRAP: Self = Self(7);
4258}
4259#[doc(alias = "VkStructureType")]
4261#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
4262#[repr(transparent)]
4263pub struct StructureType(pub i32);
4264impl std::fmt::Debug for StructureType {
4265 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4266 f.write_str(
4267 match self {
4268 &Self::APPLICATION_INFO => "APPLICATION_INFO",
4269 &Self::INSTANCE_CREATE_INFO => "INSTANCE_CREATE_INFO",
4270 &Self::DEVICE_QUEUE_CREATE_INFO => "DEVICE_QUEUE_CREATE_INFO",
4271 &Self::DEVICE_CREATE_INFO => "DEVICE_CREATE_INFO",
4272 &Self::SUBMIT_INFO => "SUBMIT_INFO",
4273 &Self::MEMORY_ALLOCATE_INFO => "MEMORY_ALLOCATE_INFO",
4274 &Self::MAPPED_MEMORY_RANGE => "MAPPED_MEMORY_RANGE",
4275 &Self::BIND_SPARSE_INFO => "BIND_SPARSE_INFO",
4276 &Self::FENCE_CREATE_INFO => "FENCE_CREATE_INFO",
4277 &Self::SEMAPHORE_CREATE_INFO => "SEMAPHORE_CREATE_INFO",
4278 &Self::EVENT_CREATE_INFO => "EVENT_CREATE_INFO",
4279 &Self::QUERY_POOL_CREATE_INFO => "QUERY_POOL_CREATE_INFO",
4280 &Self::BUFFER_CREATE_INFO => "BUFFER_CREATE_INFO",
4281 &Self::BUFFER_VIEW_CREATE_INFO => "BUFFER_VIEW_CREATE_INFO",
4282 &Self::IMAGE_CREATE_INFO => "IMAGE_CREATE_INFO",
4283 &Self::IMAGE_VIEW_CREATE_INFO => "IMAGE_VIEW_CREATE_INFO",
4284 &Self::SHADER_MODULE_CREATE_INFO => "SHADER_MODULE_CREATE_INFO",
4285 &Self::PIPELINE_CACHE_CREATE_INFO => "PIPELINE_CACHE_CREATE_INFO",
4286 &Self::PIPELINE_SHADER_STAGE_CREATE_INFO => {
4287 "PIPELINE_SHADER_STAGE_CREATE_INFO"
4288 }
4289 &Self::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => {
4290 "PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"
4291 }
4292 &Self::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => {
4293 "PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"
4294 }
4295 &Self::PIPELINE_TESSELLATION_STATE_CREATE_INFO => {
4296 "PIPELINE_TESSELLATION_STATE_CREATE_INFO"
4297 }
4298 &Self::PIPELINE_VIEWPORT_STATE_CREATE_INFO => {
4299 "PIPELINE_VIEWPORT_STATE_CREATE_INFO"
4300 }
4301 &Self::PIPELINE_RASTERIZATION_STATE_CREATE_INFO => {
4302 "PIPELINE_RASTERIZATION_STATE_CREATE_INFO"
4303 }
4304 &Self::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => {
4305 "PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"
4306 }
4307 &Self::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => {
4308 "PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"
4309 }
4310 &Self::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => {
4311 "PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"
4312 }
4313 &Self::PIPELINE_DYNAMIC_STATE_CREATE_INFO => {
4314 "PIPELINE_DYNAMIC_STATE_CREATE_INFO"
4315 }
4316 &Self::GRAPHICS_PIPELINE_CREATE_INFO => "GRAPHICS_PIPELINE_CREATE_INFO",
4317 &Self::COMPUTE_PIPELINE_CREATE_INFO => "COMPUTE_PIPELINE_CREATE_INFO",
4318 &Self::PIPELINE_LAYOUT_CREATE_INFO => "PIPELINE_LAYOUT_CREATE_INFO",
4319 &Self::SAMPLER_CREATE_INFO => "SAMPLER_CREATE_INFO",
4320 &Self::DESCRIPTOR_SET_LAYOUT_CREATE_INFO => {
4321 "DESCRIPTOR_SET_LAYOUT_CREATE_INFO"
4322 }
4323 &Self::DESCRIPTOR_POOL_CREATE_INFO => "DESCRIPTOR_POOL_CREATE_INFO",
4324 &Self::DESCRIPTOR_SET_ALLOCATE_INFO => "DESCRIPTOR_SET_ALLOCATE_INFO",
4325 &Self::WRITE_DESCRIPTOR_SET => "WRITE_DESCRIPTOR_SET",
4326 &Self::COPY_DESCRIPTOR_SET => "COPY_DESCRIPTOR_SET",
4327 &Self::FRAMEBUFFER_CREATE_INFO => "FRAMEBUFFER_CREATE_INFO",
4328 &Self::RENDER_PASS_CREATE_INFO => "RENDER_PASS_CREATE_INFO",
4329 &Self::COMMAND_POOL_CREATE_INFO => "COMMAND_POOL_CREATE_INFO",
4330 &Self::COMMAND_BUFFER_ALLOCATE_INFO => "COMMAND_BUFFER_ALLOCATE_INFO",
4331 &Self::COMMAND_BUFFER_INHERITANCE_INFO => {
4332 "COMMAND_BUFFER_INHERITANCE_INFO"
4333 }
4334 &Self::COMMAND_BUFFER_BEGIN_INFO => "COMMAND_BUFFER_BEGIN_INFO",
4335 &Self::RENDER_PASS_BEGIN_INFO => "RENDER_PASS_BEGIN_INFO",
4336 &Self::BUFFER_MEMORY_BARRIER => "BUFFER_MEMORY_BARRIER",
4337 &Self::IMAGE_MEMORY_BARRIER => "IMAGE_MEMORY_BARRIER",
4338 &Self::MEMORY_BARRIER => "MEMORY_BARRIER",
4339 &Self::LOADER_INSTANCE_CREATE_INFO => "LOADER_INSTANCE_CREATE_INFO",
4340 &Self::LOADER_DEVICE_CREATE_INFO => "LOADER_DEVICE_CREATE_INFO",
4341 &Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => {
4342 "PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"
4343 }
4344 &Self::BIND_BUFFER_MEMORY_INFO => "BIND_BUFFER_MEMORY_INFO",
4345 &Self::BIND_IMAGE_MEMORY_INFO => "BIND_IMAGE_MEMORY_INFO",
4346 &Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => {
4347 "PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"
4348 }
4349 &Self::MEMORY_DEDICATED_REQUIREMENTS => "MEMORY_DEDICATED_REQUIREMENTS",
4350 &Self::MEMORY_DEDICATED_ALLOCATE_INFO => "MEMORY_DEDICATED_ALLOCATE_INFO",
4351 &Self::MEMORY_ALLOCATE_FLAGS_INFO => "MEMORY_ALLOCATE_FLAGS_INFO",
4352 &Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => {
4353 "DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"
4354 }
4355 &Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => {
4356 "DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"
4357 }
4358 &Self::DEVICE_GROUP_SUBMIT_INFO => "DEVICE_GROUP_SUBMIT_INFO",
4359 &Self::DEVICE_GROUP_BIND_SPARSE_INFO => "DEVICE_GROUP_BIND_SPARSE_INFO",
4360 &Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => {
4361 "BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"
4362 }
4363 &Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => {
4364 "BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"
4365 }
4366 &Self::PHYSICAL_DEVICE_GROUP_PROPERTIES => {
4367 "PHYSICAL_DEVICE_GROUP_PROPERTIES"
4368 }
4369 &Self::DEVICE_GROUP_DEVICE_CREATE_INFO => {
4370 "DEVICE_GROUP_DEVICE_CREATE_INFO"
4371 }
4372 &Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2 => {
4373 "BUFFER_MEMORY_REQUIREMENTS_INFO_2"
4374 }
4375 &Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2 => {
4376 "IMAGE_MEMORY_REQUIREMENTS_INFO_2"
4377 }
4378 &Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => {
4379 "IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2"
4380 }
4381 &Self::MEMORY_REQUIREMENTS_2 => "MEMORY_REQUIREMENTS_2",
4382 &Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 => {
4383 "SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"
4384 }
4385 &Self::PHYSICAL_DEVICE_FEATURES_2 => "PHYSICAL_DEVICE_FEATURES_2",
4386 &Self::PHYSICAL_DEVICE_PROPERTIES_2 => "PHYSICAL_DEVICE_PROPERTIES_2",
4387 &Self::FORMAT_PROPERTIES_2 => "FORMAT_PROPERTIES_2",
4388 &Self::IMAGE_FORMAT_PROPERTIES_2 => "IMAGE_FORMAT_PROPERTIES_2",
4389 &Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 => {
4390 "PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"
4391 }
4392 &Self::QUEUE_FAMILY_PROPERTIES_2 => "QUEUE_FAMILY_PROPERTIES_2",
4393 &Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 => {
4394 "PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"
4395 }
4396 &Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2 => {
4397 "SPARSE_IMAGE_FORMAT_PROPERTIES_2"
4398 }
4399 &Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 => {
4400 "PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2"
4401 }
4402 &Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES => {
4403 "PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"
4404 }
4405 &Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO => {
4406 "RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"
4407 }
4408 &Self::IMAGE_VIEW_USAGE_CREATE_INFO => "IMAGE_VIEW_USAGE_CREATE_INFO",
4409 &Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO => {
4410 "PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"
4411 }
4412 &Self::RENDER_PASS_MULTIVIEW_CREATE_INFO => {
4413 "RENDER_PASS_MULTIVIEW_CREATE_INFO"
4414 }
4415 &Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES => {
4416 "PHYSICAL_DEVICE_MULTIVIEW_FEATURES"
4417 }
4418 &Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES => {
4419 "PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"
4420 }
4421 &Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES => {
4422 "PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"
4423 }
4424 &Self::PROTECTED_SUBMIT_INFO => "PROTECTED_SUBMIT_INFO",
4425 &Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES => {
4426 "PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"
4427 }
4428 &Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES => {
4429 "PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"
4430 }
4431 &Self::DEVICE_QUEUE_INFO_2 => "DEVICE_QUEUE_INFO_2",
4432 &Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO => {
4433 "SAMPLER_YCBCR_CONVERSION_CREATE_INFO"
4434 }
4435 &Self::SAMPLER_YCBCR_CONVERSION_INFO => "SAMPLER_YCBCR_CONVERSION_INFO",
4436 &Self::BIND_IMAGE_PLANE_MEMORY_INFO => "BIND_IMAGE_PLANE_MEMORY_INFO",
4437 &Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO => {
4438 "IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"
4439 }
4440 &Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES => {
4441 "PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"
4442 }
4443 &Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES => {
4444 "SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"
4445 }
4446 &Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO => {
4447 "DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO"
4448 }
4449 &Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO => {
4450 "PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"
4451 }
4452 &Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES => {
4453 "EXTERNAL_IMAGE_FORMAT_PROPERTIES"
4454 }
4455 &Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO => {
4456 "PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"
4457 }
4458 &Self::EXTERNAL_BUFFER_PROPERTIES => "EXTERNAL_BUFFER_PROPERTIES",
4459 &Self::PHYSICAL_DEVICE_ID_PROPERTIES => "PHYSICAL_DEVICE_ID_PROPERTIES",
4460 &Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO => {
4461 "EXTERNAL_MEMORY_BUFFER_CREATE_INFO"
4462 }
4463 &Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO => {
4464 "EXTERNAL_MEMORY_IMAGE_CREATE_INFO"
4465 }
4466 &Self::EXPORT_MEMORY_ALLOCATE_INFO => "EXPORT_MEMORY_ALLOCATE_INFO",
4467 &Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO => {
4468 "PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"
4469 }
4470 &Self::EXTERNAL_FENCE_PROPERTIES => "EXTERNAL_FENCE_PROPERTIES",
4471 &Self::EXPORT_FENCE_CREATE_INFO => "EXPORT_FENCE_CREATE_INFO",
4472 &Self::EXPORT_SEMAPHORE_CREATE_INFO => "EXPORT_SEMAPHORE_CREATE_INFO",
4473 &Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO => {
4474 "PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"
4475 }
4476 &Self::EXTERNAL_SEMAPHORE_PROPERTIES => "EXTERNAL_SEMAPHORE_PROPERTIES",
4477 &Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES => {
4478 "PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"
4479 }
4480 &Self::DESCRIPTOR_SET_LAYOUT_SUPPORT => "DESCRIPTOR_SET_LAYOUT_SUPPORT",
4481 &Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES => {
4482 "PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"
4483 }
4484 &Self::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES => {
4485 "PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"
4486 }
4487 &Self::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES => {
4488 "PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"
4489 }
4490 &Self::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES => {
4491 "PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"
4492 }
4493 &Self::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES => {
4494 "PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"
4495 }
4496 &Self::IMAGE_FORMAT_LIST_CREATE_INFO => "IMAGE_FORMAT_LIST_CREATE_INFO",
4497 &Self::ATTACHMENT_DESCRIPTION_2 => "ATTACHMENT_DESCRIPTION_2",
4498 &Self::ATTACHMENT_REFERENCE_2 => "ATTACHMENT_REFERENCE_2",
4499 &Self::SUBPASS_DESCRIPTION_2 => "SUBPASS_DESCRIPTION_2",
4500 &Self::SUBPASS_DEPENDENCY_2 => "SUBPASS_DEPENDENCY_2",
4501 &Self::RENDER_PASS_CREATE_INFO_2 => "RENDER_PASS_CREATE_INFO_2",
4502 &Self::SUBPASS_BEGIN_INFO => "SUBPASS_BEGIN_INFO",
4503 &Self::SUBPASS_END_INFO => "SUBPASS_END_INFO",
4504 &Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES => {
4505 "PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"
4506 }
4507 &Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES => {
4508 "PHYSICAL_DEVICE_DRIVER_PROPERTIES"
4509 }
4510 &Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES => {
4511 "PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"
4512 }
4513 &Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES => {
4514 "PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"
4515 }
4516 &Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES => {
4517 "PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"
4518 }
4519 &Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO => {
4520 "DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"
4521 }
4522 &Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES => {
4523 "PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"
4524 }
4525 &Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES => {
4526 "PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"
4527 }
4528 &Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO => {
4529 "DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"
4530 }
4531 &Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT => {
4532 "DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"
4533 }
4534 &Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES => {
4535 "PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"
4536 }
4537 &Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE => {
4538 "SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"
4539 }
4540 &Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES => {
4541 "PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"
4542 }
4543 &Self::IMAGE_STENCIL_USAGE_CREATE_INFO => {
4544 "IMAGE_STENCIL_USAGE_CREATE_INFO"
4545 }
4546 &Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES => {
4547 "PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"
4548 }
4549 &Self::SAMPLER_REDUCTION_MODE_CREATE_INFO => {
4550 "SAMPLER_REDUCTION_MODE_CREATE_INFO"
4551 }
4552 &Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES => {
4553 "PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"
4554 }
4555 &Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES => {
4556 "PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"
4557 }
4558 &Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO => {
4559 "FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"
4560 }
4561 &Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO => {
4562 "FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"
4563 }
4564 &Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO => {
4565 "RENDER_PASS_ATTACHMENT_BEGIN_INFO"
4566 }
4567 &Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES => {
4568 "PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"
4569 }
4570 &Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES => {
4571 "PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"
4572 }
4573 &Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES => {
4574 "PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"
4575 }
4576 &Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT => {
4577 "ATTACHMENT_REFERENCE_STENCIL_LAYOUT"
4578 }
4579 &Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT => {
4580 "ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"
4581 }
4582 &Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES => {
4583 "PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"
4584 }
4585 &Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES => {
4586 "PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"
4587 }
4588 &Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES => {
4589 "PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"
4590 }
4591 &Self::SEMAPHORE_TYPE_CREATE_INFO => "SEMAPHORE_TYPE_CREATE_INFO",
4592 &Self::TIMELINE_SEMAPHORE_SUBMIT_INFO => "TIMELINE_SEMAPHORE_SUBMIT_INFO",
4593 &Self::SEMAPHORE_WAIT_INFO => "SEMAPHORE_WAIT_INFO",
4594 &Self::SEMAPHORE_SIGNAL_INFO => "SEMAPHORE_SIGNAL_INFO",
4595 &Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES => {
4596 "PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"
4597 }
4598 &Self::BUFFER_DEVICE_ADDRESS_INFO => "BUFFER_DEVICE_ADDRESS_INFO",
4599 &Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO => {
4600 "BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"
4601 }
4602 &Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO => {
4603 "MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"
4604 }
4605 &Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO => {
4606 "DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"
4607 }
4608 &Self::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES => {
4609 "PHYSICAL_DEVICE_VULKAN_1_3_FEATURES"
4610 }
4611 &Self::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES => {
4612 "PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES"
4613 }
4614 &Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO => {
4615 "PIPELINE_CREATION_FEEDBACK_CREATE_INFO"
4616 }
4617 &Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES => {
4618 "PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES"
4619 }
4620 &Self::PHYSICAL_DEVICE_TOOL_PROPERTIES => {
4621 "PHYSICAL_DEVICE_TOOL_PROPERTIES"
4622 }
4623 &Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES => {
4624 "PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES"
4625 }
4626 &Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES => {
4627 "PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES"
4628 }
4629 &Self::DEVICE_PRIVATE_DATA_CREATE_INFO => {
4630 "DEVICE_PRIVATE_DATA_CREATE_INFO"
4631 }
4632 &Self::PRIVATE_DATA_SLOT_CREATE_INFO => "PRIVATE_DATA_SLOT_CREATE_INFO",
4633 &Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES => {
4634 "PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES"
4635 }
4636 &Self::MEMORY_BARRIER_2 => "MEMORY_BARRIER_2",
4637 &Self::BUFFER_MEMORY_BARRIER_2 => "BUFFER_MEMORY_BARRIER_2",
4638 &Self::IMAGE_MEMORY_BARRIER_2 => "IMAGE_MEMORY_BARRIER_2",
4639 &Self::DEPENDENCY_INFO => "DEPENDENCY_INFO",
4640 &Self::SUBMIT_INFO_2 => "SUBMIT_INFO_2",
4641 &Self::SEMAPHORE_SUBMIT_INFO => "SEMAPHORE_SUBMIT_INFO",
4642 &Self::COMMAND_BUFFER_SUBMIT_INFO => "COMMAND_BUFFER_SUBMIT_INFO",
4643 &Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES => {
4644 "PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES"
4645 }
4646 &Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES => {
4647 "PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES"
4648 }
4649 &Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES => {
4650 "PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES"
4651 }
4652 &Self::COPY_BUFFER_INFO_2 => "COPY_BUFFER_INFO_2",
4653 &Self::COPY_IMAGE_INFO_2 => "COPY_IMAGE_INFO_2",
4654 &Self::COPY_BUFFER_TO_IMAGE_INFO_2 => "COPY_BUFFER_TO_IMAGE_INFO_2",
4655 &Self::COPY_IMAGE_TO_BUFFER_INFO_2 => "COPY_IMAGE_TO_BUFFER_INFO_2",
4656 &Self::BLIT_IMAGE_INFO_2 => "BLIT_IMAGE_INFO_2",
4657 &Self::RESOLVE_IMAGE_INFO_2 => "RESOLVE_IMAGE_INFO_2",
4658 &Self::BUFFER_COPY_2 => "BUFFER_COPY_2",
4659 &Self::IMAGE_COPY_2 => "IMAGE_COPY_2",
4660 &Self::IMAGE_BLIT_2 => "IMAGE_BLIT_2",
4661 &Self::BUFFER_IMAGE_COPY_2 => "BUFFER_IMAGE_COPY_2",
4662 &Self::IMAGE_RESOLVE_2 => "IMAGE_RESOLVE_2",
4663 &Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES => {
4664 "PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES"
4665 }
4666 &Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO => {
4667 "PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO"
4668 }
4669 &Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES => {
4670 "PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES"
4671 }
4672 &Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES => {
4673 "PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES"
4674 }
4675 &Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES => {
4676 "PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES"
4677 }
4678 &Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK => {
4679 "WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK"
4680 }
4681 &Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO => {
4682 "DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO"
4683 }
4684 &Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES => {
4685 "PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES"
4686 }
4687 &Self::RENDERING_INFO => "RENDERING_INFO",
4688 &Self::RENDERING_ATTACHMENT_INFO => "RENDERING_ATTACHMENT_INFO",
4689 &Self::PIPELINE_RENDERING_CREATE_INFO => "PIPELINE_RENDERING_CREATE_INFO",
4690 &Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES => {
4691 "PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES"
4692 }
4693 &Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO => {
4694 "COMMAND_BUFFER_INHERITANCE_RENDERING_INFO"
4695 }
4696 &Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES => {
4697 "PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES"
4698 }
4699 &Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES => {
4700 "PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES"
4701 }
4702 &Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES => {
4703 "PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES"
4704 }
4705 &Self::FORMAT_PROPERTIES_3 => "FORMAT_PROPERTIES_3",
4706 &Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES => {
4707 "PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES"
4708 }
4709 &Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES => {
4710 "PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES"
4711 }
4712 &Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS => {
4713 "DEVICE_BUFFER_MEMORY_REQUIREMENTS"
4714 }
4715 &Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS => {
4716 "DEVICE_IMAGE_MEMORY_REQUIREMENTS"
4717 }
4718 &Self::SWAPCHAIN_CREATE_INFO_KHR => "SWAPCHAIN_CREATE_INFO_KHR",
4719 &Self::PRESENT_INFO_KHR => "PRESENT_INFO_KHR",
4720 &Self::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR => {
4721 "DEVICE_GROUP_PRESENT_CAPABILITIES_KHR"
4722 }
4723 &Self::IMAGE_SWAPCHAIN_CREATE_INFO_KHR => {
4724 "IMAGE_SWAPCHAIN_CREATE_INFO_KHR"
4725 }
4726 &Self::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR => {
4727 "BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR"
4728 }
4729 &Self::ACQUIRE_NEXT_IMAGE_INFO_KHR => "ACQUIRE_NEXT_IMAGE_INFO_KHR",
4730 &Self::DEVICE_GROUP_PRESENT_INFO_KHR => "DEVICE_GROUP_PRESENT_INFO_KHR",
4731 &Self::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR => {
4732 "DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR"
4733 }
4734 &Self::DISPLAY_MODE_CREATE_INFO_KHR => "DISPLAY_MODE_CREATE_INFO_KHR",
4735 &Self::DISPLAY_SURFACE_CREATE_INFO_KHR => {
4736 "DISPLAY_SURFACE_CREATE_INFO_KHR"
4737 }
4738 &Self::DISPLAY_PRESENT_INFO_KHR => "DISPLAY_PRESENT_INFO_KHR",
4739 &Self::XLIB_SURFACE_CREATE_INFO_KHR => "XLIB_SURFACE_CREATE_INFO_KHR",
4740 &Self::XCB_SURFACE_CREATE_INFO_KHR => "XCB_SURFACE_CREATE_INFO_KHR",
4741 &Self::WAYLAND_SURFACE_CREATE_INFO_KHR => {
4742 "WAYLAND_SURFACE_CREATE_INFO_KHR"
4743 }
4744 &Self::ANDROID_SURFACE_CREATE_INFO_KHR => {
4745 "ANDROID_SURFACE_CREATE_INFO_KHR"
4746 }
4747 &Self::WIN32_SURFACE_CREATE_INFO_KHR => "WIN32_SURFACE_CREATE_INFO_KHR",
4748 &Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT => {
4749 "DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT"
4750 }
4751 &Self::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD => {
4752 "PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD"
4753 }
4754 &Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => {
4755 "DEBUG_MARKER_OBJECT_NAME_INFO_EXT"
4756 }
4757 &Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => {
4758 "DEBUG_MARKER_OBJECT_TAG_INFO_EXT"
4759 }
4760 &Self::DEBUG_MARKER_MARKER_INFO_EXT => "DEBUG_MARKER_MARKER_INFO_EXT",
4761 &Self::VIDEO_PROFILE_KHR => "VIDEO_PROFILE_KHR",
4762 &Self::VIDEO_CAPABILITIES_KHR => "VIDEO_CAPABILITIES_KHR",
4763 &Self::VIDEO_PICTURE_RESOURCE_KHR => "VIDEO_PICTURE_RESOURCE_KHR",
4764 &Self::VIDEO_GET_MEMORY_PROPERTIES_KHR => {
4765 "VIDEO_GET_MEMORY_PROPERTIES_KHR"
4766 }
4767 &Self::VIDEO_BIND_MEMORY_KHR => "VIDEO_BIND_MEMORY_KHR",
4768 &Self::VIDEO_SESSION_CREATE_INFO_KHR => "VIDEO_SESSION_CREATE_INFO_KHR",
4769 &Self::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR => {
4770 "VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR"
4771 }
4772 &Self::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR => {
4773 "VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR"
4774 }
4775 &Self::VIDEO_BEGIN_CODING_INFO_KHR => "VIDEO_BEGIN_CODING_INFO_KHR",
4776 &Self::VIDEO_END_CODING_INFO_KHR => "VIDEO_END_CODING_INFO_KHR",
4777 &Self::VIDEO_CODING_CONTROL_INFO_KHR => "VIDEO_CODING_CONTROL_INFO_KHR",
4778 &Self::VIDEO_REFERENCE_SLOT_KHR => "VIDEO_REFERENCE_SLOT_KHR",
4779 &Self::VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR => {
4780 "VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR"
4781 }
4782 &Self::VIDEO_PROFILES_KHR => "VIDEO_PROFILES_KHR",
4783 &Self::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR => {
4784 "PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR"
4785 }
4786 &Self::VIDEO_FORMAT_PROPERTIES_KHR => "VIDEO_FORMAT_PROPERTIES_KHR",
4787 &Self::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR => {
4788 "QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR"
4789 }
4790 &Self::VIDEO_DECODE_INFO_KHR => "VIDEO_DECODE_INFO_KHR",
4791 &Self::VIDEO_DECODE_CAPABILITIES_KHR => "VIDEO_DECODE_CAPABILITIES_KHR",
4792 &Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => {
4793 "DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV"
4794 }
4795 &Self::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV => {
4796 "DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV"
4797 }
4798 &Self::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV => {
4799 "DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV"
4800 }
4801 &Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT => {
4802 "PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT"
4803 }
4804 &Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT => {
4805 "PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT"
4806 }
4807 &Self::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT => {
4808 "PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"
4809 }
4810 &Self::CU_MODULE_CREATE_INFO_NVX => "CU_MODULE_CREATE_INFO_NVX",
4811 &Self::CU_FUNCTION_CREATE_INFO_NVX => "CU_FUNCTION_CREATE_INFO_NVX",
4812 &Self::CU_LAUNCH_INFO_NVX => "CU_LAUNCH_INFO_NVX",
4813 &Self::IMAGE_VIEW_HANDLE_INFO_NVX => "IMAGE_VIEW_HANDLE_INFO_NVX",
4814 &Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => {
4815 "IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"
4816 }
4817 &Self::VIDEO_ENCODE_H264_CAPABILITIES_EXT => {
4818 "VIDEO_ENCODE_H264_CAPABILITIES_EXT"
4819 }
4820 &Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => {
4821 "VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"
4822 }
4823 &Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => {
4824 "VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"
4825 }
4826 &Self::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT => {
4827 "VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT"
4828 }
4829 &Self::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT => {
4830 "VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"
4831 }
4832 &Self::VIDEO_ENCODE_H264_NALU_SLICE_EXT => {
4833 "VIDEO_ENCODE_H264_NALU_SLICE_EXT"
4834 }
4835 &Self::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT => {
4836 "VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT"
4837 }
4838 &Self::VIDEO_ENCODE_H264_PROFILE_EXT => "VIDEO_ENCODE_H264_PROFILE_EXT",
4839 &Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => {
4840 "VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT"
4841 }
4842 &Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => {
4843 "VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT"
4844 }
4845 &Self::VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT => {
4846 "VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT"
4847 }
4848 &Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => {
4849 "VIDEO_ENCODE_H265_CAPABILITIES_EXT"
4850 }
4851 &Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => {
4852 "VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"
4853 }
4854 &Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => {
4855 "VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"
4856 }
4857 &Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => {
4858 "VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT"
4859 }
4860 &Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => {
4861 "VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"
4862 }
4863 &Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT => {
4864 "VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT"
4865 }
4866 &Self::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT => {
4867 "VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT"
4868 }
4869 &Self::VIDEO_ENCODE_H265_PROFILE_EXT => "VIDEO_ENCODE_H265_PROFILE_EXT",
4870 &Self::VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT => {
4871 "VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT"
4872 }
4873 &Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => {
4874 "VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT"
4875 }
4876 &Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => {
4877 "VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT"
4878 }
4879 &Self::VIDEO_DECODE_H264_CAPABILITIES_EXT => {
4880 "VIDEO_DECODE_H264_CAPABILITIES_EXT"
4881 }
4882 &Self::VIDEO_DECODE_H264_PICTURE_INFO_EXT => {
4883 "VIDEO_DECODE_H264_PICTURE_INFO_EXT"
4884 }
4885 &Self::VIDEO_DECODE_H264_MVC_EXT => "VIDEO_DECODE_H264_MVC_EXT",
4886 &Self::VIDEO_DECODE_H264_PROFILE_EXT => "VIDEO_DECODE_H264_PROFILE_EXT",
4887 &Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => {
4888 "VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"
4889 }
4890 &Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => {
4891 "VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"
4892 }
4893 &Self::VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT => {
4894 "VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT"
4895 }
4896 &Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => {
4897 "TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD"
4898 }
4899 &Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => {
4900 "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"
4901 }
4902 &Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT => {
4903 "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT"
4904 }
4905 &Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD => {
4906 "ATTACHMENT_SAMPLE_COUNT_INFO_AMD"
4907 }
4908 &Self::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX => {
4909 "MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX"
4910 }
4911 &Self::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP => {
4912 "STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP"
4913 }
4914 &Self::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV => {
4915 "PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV"
4916 }
4917 &Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV => {
4918 "EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV"
4919 }
4920 &Self::EXPORT_MEMORY_ALLOCATE_INFO_NV => "EXPORT_MEMORY_ALLOCATE_INFO_NV",
4921 &Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV => {
4922 "IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"
4923 }
4924 &Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV => {
4925 "EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"
4926 }
4927 &Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV => {
4928 "WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV"
4929 }
4930 &Self::VALIDATION_FLAGS_EXT => "VALIDATION_FLAGS_EXT",
4931 &Self::VI_SURFACE_CREATE_INFO_NN => "VI_SURFACE_CREATE_INFO_NN",
4932 &Self::IMAGE_VIEW_ASTC_DECODE_MODE_EXT => {
4933 "IMAGE_VIEW_ASTC_DECODE_MODE_EXT"
4934 }
4935 &Self::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT => {
4936 "PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT"
4937 }
4938 &Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => {
4939 "IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR"
4940 }
4941 &Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR => {
4942 "EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR"
4943 }
4944 &Self::MEMORY_WIN32_HANDLE_PROPERTIES_KHR => {
4945 "MEMORY_WIN32_HANDLE_PROPERTIES_KHR"
4946 }
4947 &Self::MEMORY_GET_WIN32_HANDLE_INFO_KHR => {
4948 "MEMORY_GET_WIN32_HANDLE_INFO_KHR"
4949 }
4950 &Self::IMPORT_MEMORY_FD_INFO_KHR => "IMPORT_MEMORY_FD_INFO_KHR",
4951 &Self::MEMORY_FD_PROPERTIES_KHR => "MEMORY_FD_PROPERTIES_KHR",
4952 &Self::MEMORY_GET_FD_INFO_KHR => "MEMORY_GET_FD_INFO_KHR",
4953 &Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR => {
4954 "WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR"
4955 }
4956 &Self::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => {
4957 "IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"
4958 }
4959 &Self::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => {
4960 "EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR"
4961 }
4962 &Self::D3D12_FENCE_SUBMIT_INFO_KHR => "D3D12_FENCE_SUBMIT_INFO_KHR",
4963 &Self::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR => {
4964 "SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR"
4965 }
4966 &Self::IMPORT_SEMAPHORE_FD_INFO_KHR => "IMPORT_SEMAPHORE_FD_INFO_KHR",
4967 &Self::SEMAPHORE_GET_FD_INFO_KHR => "SEMAPHORE_GET_FD_INFO_KHR",
4968 &Self::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR => {
4969 "PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR"
4970 }
4971 &Self::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT => {
4972 "COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT"
4973 }
4974 &Self::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT => {
4975 "PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT"
4976 }
4977 &Self::CONDITIONAL_RENDERING_BEGIN_INFO_EXT => {
4978 "CONDITIONAL_RENDERING_BEGIN_INFO_EXT"
4979 }
4980 &Self::PRESENT_REGIONS_KHR => "PRESENT_REGIONS_KHR",
4981 &Self::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV => {
4982 "PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV"
4983 }
4984 &Self::SURFACE_CAPABILITIES_2_EXT => "SURFACE_CAPABILITIES_2_EXT",
4985 &Self::DISPLAY_POWER_INFO_EXT => "DISPLAY_POWER_INFO_EXT",
4986 &Self::DEVICE_EVENT_INFO_EXT => "DEVICE_EVENT_INFO_EXT",
4987 &Self::DISPLAY_EVENT_INFO_EXT => "DISPLAY_EVENT_INFO_EXT",
4988 &Self::SWAPCHAIN_COUNTER_CREATE_INFO_EXT => {
4989 "SWAPCHAIN_COUNTER_CREATE_INFO_EXT"
4990 }
4991 &Self::PRESENT_TIMES_INFO_GOOGLE => "PRESENT_TIMES_INFO_GOOGLE",
4992 &Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX => {
4993 "PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"
4994 }
4995 &Self::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV => {
4996 "PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV"
4997 }
4998 &Self::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT => {
4999 "PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT"
5000 }
5001 &Self::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT => {
5002 "PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT"
5003 }
5004 &Self::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT => {
5005 "PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT"
5006 }
5007 &Self::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT => {
5008 "PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT"
5009 }
5010 &Self::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT => {
5011 "PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"
5012 }
5013 &Self::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT => {
5014 "PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"
5015 }
5016 &Self::HDR_METADATA_EXT => "HDR_METADATA_EXT",
5017 &Self::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR => {
5018 "SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"
5019 }
5020 &Self::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR => {
5021 "IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"
5022 }
5023 &Self::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR => {
5024 "EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"
5025 }
5026 &Self::FENCE_GET_WIN32_HANDLE_INFO_KHR => {
5027 "FENCE_GET_WIN32_HANDLE_INFO_KHR"
5028 }
5029 &Self::IMPORT_FENCE_FD_INFO_KHR => "IMPORT_FENCE_FD_INFO_KHR",
5030 &Self::FENCE_GET_FD_INFO_KHR => "FENCE_GET_FD_INFO_KHR",
5031 &Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR => {
5032 "PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR"
5033 }
5034 &Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR => {
5035 "PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"
5036 }
5037 &Self::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR => {
5038 "QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR"
5039 }
5040 &Self::PERFORMANCE_QUERY_SUBMIT_INFO_KHR => {
5041 "PERFORMANCE_QUERY_SUBMIT_INFO_KHR"
5042 }
5043 &Self::ACQUIRE_PROFILING_LOCK_INFO_KHR => {
5044 "ACQUIRE_PROFILING_LOCK_INFO_KHR"
5045 }
5046 &Self::PERFORMANCE_COUNTER_KHR => "PERFORMANCE_COUNTER_KHR",
5047 &Self::PERFORMANCE_COUNTER_DESCRIPTION_KHR => {
5048 "PERFORMANCE_COUNTER_DESCRIPTION_KHR"
5049 }
5050 &Self::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR => {
5051 "PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"
5052 }
5053 &Self::SURFACE_CAPABILITIES_2_KHR => "SURFACE_CAPABILITIES_2_KHR",
5054 &Self::SURFACE_FORMAT_2_KHR => "SURFACE_FORMAT_2_KHR",
5055 &Self::DISPLAY_PROPERTIES_2_KHR => "DISPLAY_PROPERTIES_2_KHR",
5056 &Self::DISPLAY_PLANE_PROPERTIES_2_KHR => "DISPLAY_PLANE_PROPERTIES_2_KHR",
5057 &Self::DISPLAY_MODE_PROPERTIES_2_KHR => "DISPLAY_MODE_PROPERTIES_2_KHR",
5058 &Self::DISPLAY_PLANE_INFO_2_KHR => "DISPLAY_PLANE_INFO_2_KHR",
5059 &Self::DISPLAY_PLANE_CAPABILITIES_2_KHR => {
5060 "DISPLAY_PLANE_CAPABILITIES_2_KHR"
5061 }
5062 &Self::IOS_SURFACE_CREATE_INFO_MVK => "IOS_SURFACE_CREATE_INFO_MVK",
5063 &Self::MACOS_SURFACE_CREATE_INFO_MVK => "MACOS_SURFACE_CREATE_INFO_MVK",
5064 &Self::DEBUG_UTILS_OBJECT_NAME_INFO_EXT => {
5065 "DEBUG_UTILS_OBJECT_NAME_INFO_EXT"
5066 }
5067 &Self::DEBUG_UTILS_OBJECT_TAG_INFO_EXT => {
5068 "DEBUG_UTILS_OBJECT_TAG_INFO_EXT"
5069 }
5070 &Self::DEBUG_UTILS_LABEL_EXT => "DEBUG_UTILS_LABEL_EXT",
5071 &Self::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT => {
5072 "DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"
5073 }
5074 &Self::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT => {
5075 "DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"
5076 }
5077 &Self::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID => {
5078 "ANDROID_HARDWARE_BUFFER_USAGE_ANDROID"
5079 }
5080 &Self::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID => {
5081 "ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID"
5082 }
5083 &Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID => {
5084 "ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID"
5085 }
5086 &Self::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => {
5087 "IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"
5088 }
5089 &Self::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => {
5090 "MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"
5091 }
5092 &Self::EXTERNAL_FORMAT_ANDROID => "EXTERNAL_FORMAT_ANDROID",
5093 &Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID => {
5094 "ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"
5095 }
5096 &Self::SAMPLE_LOCATIONS_INFO_EXT => "SAMPLE_LOCATIONS_INFO_EXT",
5097 &Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => {
5098 "RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"
5099 }
5100 &Self::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT => {
5101 "PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"
5102 }
5103 &Self::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT => {
5104 "PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT"
5105 }
5106 &Self::MULTISAMPLE_PROPERTIES_EXT => "MULTISAMPLE_PROPERTIES_EXT",
5107 &Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT => {
5108 "PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT"
5109 }
5110 &Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT => {
5111 "PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"
5112 }
5113 &Self::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT => {
5114 "PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"
5115 }
5116 &Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => {
5117 "PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV"
5118 }
5119 &Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR => {
5120 "WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR"
5121 }
5122 &Self::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR => {
5123 "ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR"
5124 }
5125 &Self::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR => {
5126 "ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR"
5127 }
5128 &Self::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR => {
5129 "ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR"
5130 }
5131 &Self::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR => {
5132 "ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR"
5133 }
5134 &Self::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR => {
5135 "ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR"
5136 }
5137 &Self::ACCELERATION_STRUCTURE_GEOMETRY_KHR => {
5138 "ACCELERATION_STRUCTURE_GEOMETRY_KHR"
5139 }
5140 &Self::ACCELERATION_STRUCTURE_VERSION_INFO_KHR => {
5141 "ACCELERATION_STRUCTURE_VERSION_INFO_KHR"
5142 }
5143 &Self::COPY_ACCELERATION_STRUCTURE_INFO_KHR => {
5144 "COPY_ACCELERATION_STRUCTURE_INFO_KHR"
5145 }
5146 &Self::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR => {
5147 "COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR"
5148 }
5149 &Self::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR => {
5150 "COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR"
5151 }
5152 &Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR => {
5153 "PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR"
5154 }
5155 &Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR => {
5156 "PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR"
5157 }
5158 &Self::ACCELERATION_STRUCTURE_CREATE_INFO_KHR => {
5159 "ACCELERATION_STRUCTURE_CREATE_INFO_KHR"
5160 }
5161 &Self::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR => {
5162 "ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR"
5163 }
5164 &Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR => {
5165 "PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR"
5166 }
5167 &Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR => {
5168 "PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR"
5169 }
5170 &Self::RAY_TRACING_PIPELINE_CREATE_INFO_KHR => {
5171 "RAY_TRACING_PIPELINE_CREATE_INFO_KHR"
5172 }
5173 &Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR => {
5174 "RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR"
5175 }
5176 &Self::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR => {
5177 "RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR"
5178 }
5179 &Self::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR => {
5180 "PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR"
5181 }
5182 &Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => {
5183 "PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV"
5184 }
5185 &Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV => {
5186 "PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV"
5187 }
5188 &Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV => {
5189 "PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV"
5190 }
5191 &Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT => {
5192 "DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT"
5193 }
5194 &Self::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT => {
5195 "PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT"
5196 }
5197 &Self::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT => {
5198 "IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT"
5199 }
5200 &Self::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT => {
5201 "IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT"
5202 }
5203 &Self::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT => {
5204 "IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT"
5205 }
5206 &Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT => {
5207 "DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT"
5208 }
5209 &Self::VALIDATION_CACHE_CREATE_INFO_EXT => {
5210 "VALIDATION_CACHE_CREATE_INFO_EXT"
5211 }
5212 &Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => {
5213 "SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT"
5214 }
5215 &Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR => {
5216 "PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR"
5217 }
5218 &Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR => {
5219 "PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR"
5220 }
5221 &Self::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV => {
5222 "PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV"
5223 }
5224 &Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV => {
5225 "PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV"
5226 }
5227 &Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV => {
5228 "PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV"
5229 }
5230 &Self::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV => {
5231 "PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV"
5232 }
5233 &Self::RAY_TRACING_PIPELINE_CREATE_INFO_NV => {
5234 "RAY_TRACING_PIPELINE_CREATE_INFO_NV"
5235 }
5236 &Self::ACCELERATION_STRUCTURE_CREATE_INFO_NV => {
5237 "ACCELERATION_STRUCTURE_CREATE_INFO_NV"
5238 }
5239 &Self::GEOMETRY_NV => "GEOMETRY_NV",
5240 &Self::GEOMETRY_TRIANGLES_NV => "GEOMETRY_TRIANGLES_NV",
5241 &Self::GEOMETRY_AABB_NV => "GEOMETRY_AABB_NV",
5242 &Self::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV => {
5243 "BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV"
5244 }
5245 &Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV => {
5246 "WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV"
5247 }
5248 &Self::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV => {
5249 "ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV"
5250 }
5251 &Self::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV => {
5252 "PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV"
5253 }
5254 &Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV => {
5255 "RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV"
5256 }
5257 &Self::ACCELERATION_STRUCTURE_INFO_NV => "ACCELERATION_STRUCTURE_INFO_NV",
5258 &Self::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV => {
5259 "PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV"
5260 }
5261 &Self::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV => {
5262 "PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV"
5263 }
5264 &Self::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT => {
5265 "PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT"
5266 }
5267 &Self::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT => {
5268 "FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT"
5269 }
5270 &Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => {
5271 "IMPORT_MEMORY_HOST_POINTER_INFO_EXT"
5272 }
5273 &Self::MEMORY_HOST_POINTER_PROPERTIES_EXT => {
5274 "MEMORY_HOST_POINTER_PROPERTIES_EXT"
5275 }
5276 &Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT => {
5277 "PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"
5278 }
5279 &Self::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR => {
5280 "PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"
5281 }
5282 &Self::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD => {
5283 "PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"
5284 }
5285 &Self::CALIBRATED_TIMESTAMP_INFO_EXT => "CALIBRATED_TIMESTAMP_INFO_EXT",
5286 &Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => {
5287 "PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"
5288 }
5289 &Self::VIDEO_DECODE_H265_CAPABILITIES_EXT => {
5290 "VIDEO_DECODE_H265_CAPABILITIES_EXT"
5291 }
5292 &Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => {
5293 "VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"
5294 }
5295 &Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => {
5296 "VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"
5297 }
5298 &Self::VIDEO_DECODE_H265_PROFILE_EXT => "VIDEO_DECODE_H265_PROFILE_EXT",
5299 &Self::VIDEO_DECODE_H265_PICTURE_INFO_EXT => {
5300 "VIDEO_DECODE_H265_PICTURE_INFO_EXT"
5301 }
5302 &Self::VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT => {
5303 "VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT"
5304 }
5305 &Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR => {
5306 "DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR"
5307 }
5308 &Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR => {
5309 "PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR"
5310 }
5311 &Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR => {
5312 "QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR"
5313 }
5314 &Self::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD => {
5315 "DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"
5316 }
5317 &Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT => {
5318 "PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"
5319 }
5320 &Self::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT => {
5321 "PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"
5322 }
5323 &Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT => {
5324 "PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"
5325 }
5326 &Self::PRESENT_FRAME_TOKEN_GGP => "PRESENT_FRAME_TOKEN_GGP",
5327 &Self::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV => {
5328 "PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"
5329 }
5330 &Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV => {
5331 "PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"
5332 }
5333 &Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV => {
5334 "PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV"
5335 }
5336 &Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV => {
5337 "PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV"
5338 }
5339 &Self::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV => {
5340 "PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV"
5341 }
5342 &Self::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV => {
5343 "PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV"
5344 }
5345 &Self::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV => {
5346 "PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV"
5347 }
5348 &Self::CHECKPOINT_DATA_NV => "CHECKPOINT_DATA_NV",
5349 &Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV => {
5350 "QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV"
5351 }
5352 &Self::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL => {
5353 "PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL"
5354 }
5355 &Self::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL => {
5356 "QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL"
5357 }
5358 &Self::INITIALIZE_PERFORMANCE_API_INFO_INTEL => {
5359 "INITIALIZE_PERFORMANCE_API_INFO_INTEL"
5360 }
5361 &Self::PERFORMANCE_MARKER_INFO_INTEL => "PERFORMANCE_MARKER_INFO_INTEL",
5362 &Self::PERFORMANCE_STREAM_MARKER_INFO_INTEL => {
5363 "PERFORMANCE_STREAM_MARKER_INFO_INTEL"
5364 }
5365 &Self::PERFORMANCE_OVERRIDE_INFO_INTEL => {
5366 "PERFORMANCE_OVERRIDE_INFO_INTEL"
5367 }
5368 &Self::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL => {
5369 "PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL"
5370 }
5371 &Self::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT => {
5372 "PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT"
5373 }
5374 &Self::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD => {
5375 "DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD"
5376 }
5377 &Self::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD => {
5378 "SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD"
5379 }
5380 &Self::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA => {
5381 "IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA"
5382 }
5383 &Self::METAL_SURFACE_CREATE_INFO_EXT => "METAL_SURFACE_CREATE_INFO_EXT",
5384 &Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT => {
5385 "PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT"
5386 }
5387 &Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT => {
5388 "PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"
5389 }
5390 &Self::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT => {
5391 "RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"
5392 }
5393 &Self::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => {
5394 "FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"
5395 }
5396 &Self::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR => {
5397 "PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR"
5398 }
5399 &Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR => {
5400 "PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR"
5401 }
5402 &Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR => {
5403 "PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR"
5404 }
5405 &Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR => {
5406 "PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"
5407 }
5408 &Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD => {
5409 "PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD"
5410 }
5411 &Self::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD => {
5412 "PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD"
5413 }
5414 &Self::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT => {
5415 "PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT"
5416 }
5417 &Self::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT => {
5418 "PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT"
5419 }
5420 &Self::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT => {
5421 "PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT"
5422 }
5423 &Self::MEMORY_PRIORITY_ALLOCATE_INFO_EXT => {
5424 "MEMORY_PRIORITY_ALLOCATE_INFO_EXT"
5425 }
5426 &Self::SURFACE_PROTECTED_CAPABILITIES_KHR => {
5427 "SURFACE_PROTECTED_CAPABILITIES_KHR"
5428 }
5429 &Self::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV => {
5430 "PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV"
5431 }
5432 &Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT => {
5433 "PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT"
5434 }
5435 &Self::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT => {
5436 "BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT"
5437 }
5438 &Self::VALIDATION_FEATURES_EXT => "VALIDATION_FEATURES_EXT",
5439 &Self::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR => {
5440 "PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"
5441 }
5442 &Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV => {
5443 "PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV"
5444 }
5445 &Self::COOPERATIVE_MATRIX_PROPERTIES_NV => {
5446 "COOPERATIVE_MATRIX_PROPERTIES_NV"
5447 }
5448 &Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV => {
5449 "PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV"
5450 }
5451 &Self::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV => {
5452 "PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV"
5453 }
5454 &Self::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV => {
5455 "PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV"
5456 }
5457 &Self::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV => {
5458 "FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV"
5459 }
5460 &Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT => {
5461 "PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT"
5462 }
5463 &Self::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT => {
5464 "PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT"
5465 }
5466 &Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT => {
5467 "PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT"
5468 }
5469 &Self::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT => {
5470 "PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"
5471 }
5472 &Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT => {
5473 "PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"
5474 }
5475 &Self::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT => {
5476 "SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT"
5477 }
5478 &Self::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT => {
5479 "SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT"
5480 }
5481 &Self::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT => {
5482 "SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT"
5483 }
5484 &Self::HEADLESS_SURFACE_CREATE_INFO_EXT => {
5485 "HEADLESS_SURFACE_CREATE_INFO_EXT"
5486 }
5487 &Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT => {
5488 "PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT"
5489 }
5490 &Self::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT => {
5491 "PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT"
5492 }
5493 &Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT => {
5494 "PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT"
5495 }
5496 &Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT => {
5497 "PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT"
5498 }
5499 &Self::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT => {
5500 "PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT"
5501 }
5502 &Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT => {
5503 "PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT"
5504 }
5505 &Self::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR => {
5506 "PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR"
5507 }
5508 &Self::PIPELINE_INFO_KHR => "PIPELINE_INFO_KHR",
5509 &Self::PIPELINE_EXECUTABLE_PROPERTIES_KHR => {
5510 "PIPELINE_EXECUTABLE_PROPERTIES_KHR"
5511 }
5512 &Self::PIPELINE_EXECUTABLE_INFO_KHR => "PIPELINE_EXECUTABLE_INFO_KHR",
5513 &Self::PIPELINE_EXECUTABLE_STATISTIC_KHR => {
5514 "PIPELINE_EXECUTABLE_STATISTIC_KHR"
5515 }
5516 &Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => {
5517 "PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR"
5518 }
5519 &Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => {
5520 "PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT"
5521 }
5522 &Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV => {
5523 "PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV"
5524 }
5525 &Self::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV => {
5526 "GRAPHICS_SHADER_GROUP_CREATE_INFO_NV"
5527 }
5528 &Self::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV => {
5529 "GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV"
5530 }
5531 &Self::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV => {
5532 "INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"
5533 }
5534 &Self::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV => {
5535 "INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV"
5536 }
5537 &Self::GENERATED_COMMANDS_INFO_NV => "GENERATED_COMMANDS_INFO_NV",
5538 &Self::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV => {
5539 "GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV"
5540 }
5541 &Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV => {
5542 "PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV"
5543 }
5544 &Self::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV => {
5545 "PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV"
5546 }
5547 &Self::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV => {
5548 "COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV"
5549 }
5550 &Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT => {
5551 "PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT"
5552 }
5553 &Self::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM => {
5554 "COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM"
5555 }
5556 &Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => {
5557 "RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM"
5558 }
5559 &Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => {
5560 "PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT"
5561 }
5562 &Self::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT => {
5563 "DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT"
5564 }
5565 &Self::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT => {
5566 "DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT"
5567 }
5568 &Self::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT => {
5569 "PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"
5570 }
5571 &Self::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT => {
5572 "PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"
5573 }
5574 &Self::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT => {
5575 "SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT"
5576 }
5577 &Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT => {
5578 "PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT"
5579 }
5580 &Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT => {
5581 "PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT"
5582 }
5583 &Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => {
5584 "PIPELINE_LIBRARY_CREATE_INFO_KHR"
5585 }
5586 &Self::PRESENT_ID_KHR => "PRESENT_ID_KHR",
5587 &Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => {
5588 "PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"
5589 }
5590 &Self::VIDEO_ENCODE_INFO_KHR => "VIDEO_ENCODE_INFO_KHR",
5591 &Self::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR => {
5592 "VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"
5593 }
5594 &Self::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR => {
5595 "VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR"
5596 }
5597 &Self::VIDEO_ENCODE_CAPABILITIES_KHR => "VIDEO_ENCODE_CAPABILITIES_KHR",
5598 &Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => {
5599 "PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"
5600 }
5601 &Self::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV => {
5602 "DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"
5603 }
5604 &Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV => {
5605 "QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV"
5606 }
5607 &Self::CHECKPOINT_DATA_2_NV => "CHECKPOINT_DATA_2_NV",
5608 &Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT => {
5609 "PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT"
5610 }
5611 &Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT => {
5612 "PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT"
5613 }
5614 &Self::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT => {
5615 "GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT"
5616 }
5617 &Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR => {
5618 "PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR"
5619 }
5620 &Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV => {
5621 "PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"
5622 }
5623 &Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV => {
5624 "PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV"
5625 }
5626 &Self::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV => {
5627 "PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV"
5628 }
5629 &Self::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV => {
5630 "ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV"
5631 }
5632 &Self::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV => {
5633 "PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"
5634 }
5635 &Self::ACCELERATION_STRUCTURE_MOTION_INFO_NV => {
5636 "ACCELERATION_STRUCTURE_MOTION_INFO_NV"
5637 }
5638 &Self::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT => {
5639 "PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT"
5640 }
5641 &Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT => {
5642 "PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT"
5643 }
5644 &Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT => {
5645 "PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"
5646 }
5647 &Self::COPY_COMMAND_TRANSFORM_INFO_QCOM => {
5648 "COPY_COMMAND_TRANSFORM_INFO_QCOM"
5649 }
5650 &Self::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR => {
5651 "PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"
5652 }
5653 &Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT => {
5654 "PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT"
5655 }
5656 &Self::IMAGE_COMPRESSION_CONTROL_EXT => "IMAGE_COMPRESSION_CONTROL_EXT",
5657 &Self::SUBRESOURCE_LAYOUT_2_EXT => "SUBRESOURCE_LAYOUT_2_EXT",
5658 &Self::IMAGE_SUBRESOURCE_2_EXT => "IMAGE_SUBRESOURCE_2_EXT",
5659 &Self::IMAGE_COMPRESSION_PROPERTIES_EXT => {
5660 "IMAGE_COMPRESSION_PROPERTIES_EXT"
5661 }
5662 &Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => {
5663 "PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"
5664 }
5665 &Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM => {
5666 "PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM"
5667 }
5668 &Self::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT => {
5669 "PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT"
5670 }
5671 &Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => {
5672 "DIRECTFB_SURFACE_CREATE_INFO_EXT"
5673 }
5674 &Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE => {
5675 "PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE"
5676 }
5677 &Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE => {
5678 "MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE"
5679 }
5680 &Self::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT => {
5681 "PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT"
5682 }
5683 &Self::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT => {
5684 "VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT"
5685 }
5686 &Self::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT => {
5687 "VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT"
5688 }
5689 &Self::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT => {
5690 "PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"
5691 }
5692 &Self::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT => {
5693 "PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT"
5694 }
5695 &Self::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT => {
5696 "PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT"
5697 }
5698 &Self::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT => {
5699 "PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT"
5700 }
5701 &Self::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA => {
5702 "IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA"
5703 }
5704 &Self::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA => {
5705 "MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA"
5706 }
5707 &Self::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA => {
5708 "MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA"
5709 }
5710 &Self::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA => {
5711 "IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA"
5712 }
5713 &Self::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA => {
5714 "SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA"
5715 }
5716 &Self::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA => {
5717 "BUFFER_COLLECTION_CREATE_INFO_FUCHSIA"
5718 }
5719 &Self::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA => {
5720 "IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA"
5721 }
5722 &Self::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA => {
5723 "BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA"
5724 }
5725 &Self::BUFFER_COLLECTION_PROPERTIES_FUCHSIA => {
5726 "BUFFER_COLLECTION_PROPERTIES_FUCHSIA"
5727 }
5728 &Self::BUFFER_CONSTRAINTS_INFO_FUCHSIA => {
5729 "BUFFER_CONSTRAINTS_INFO_FUCHSIA"
5730 }
5731 &Self::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA => {
5732 "BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA"
5733 }
5734 &Self::IMAGE_CONSTRAINTS_INFO_FUCHSIA => "IMAGE_CONSTRAINTS_INFO_FUCHSIA",
5735 &Self::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA => {
5736 "IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA"
5737 }
5738 &Self::SYSMEM_COLOR_SPACE_FUCHSIA => "SYSMEM_COLOR_SPACE_FUCHSIA",
5739 &Self::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA => {
5740 "BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA"
5741 }
5742 &Self::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI => {
5743 "SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI"
5744 }
5745 &Self::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI => {
5746 "PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI"
5747 }
5748 &Self::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI => {
5749 "PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI"
5750 }
5751 &Self::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI => {
5752 "PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI"
5753 }
5754 &Self::MEMORY_GET_REMOTE_ADDRESS_INFO_NV => {
5755 "MEMORY_GET_REMOTE_ADDRESS_INFO_NV"
5756 }
5757 &Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => {
5758 "PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV"
5759 }
5760 &Self::PIPELINE_PROPERTIES_IDENTIFIER_EXT => {
5761 "PIPELINE_PROPERTIES_IDENTIFIER_EXT"
5762 }
5763 &Self::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT => {
5764 "PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT"
5765 }
5766 &Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT => {
5767 "PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT"
5768 }
5769 &Self::SCREEN_SURFACE_CREATE_INFO_QNX => "SCREEN_SURFACE_CREATE_INFO_QNX",
5770 &Self::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT => {
5771 "PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT"
5772 }
5773 &Self::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT => {
5774 "PIPELINE_COLOR_WRITE_CREATE_INFO_EXT"
5775 }
5776 &Self::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT => {
5777 "PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT"
5778 }
5779 &Self::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR => {
5780 "PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR"
5781 }
5782 &Self::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT => {
5783 "PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT"
5784 }
5785 &Self::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT => {
5786 "IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"
5787 }
5788 &Self::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT => {
5789 "PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT"
5790 }
5791 &Self::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT => {
5792 "PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT"
5793 }
5794 &Self::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT => {
5795 "PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT"
5796 }
5797 &Self::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT => {
5798 "PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"
5799 }
5800 &Self::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT => {
5801 "SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"
5802 }
5803 &Self::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT => {
5804 "PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"
5805 }
5806 &Self::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE => {
5807 "PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE"
5808 }
5809 &Self::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE => {
5810 "DESCRIPTOR_SET_BINDING_REFERENCE_VALVE"
5811 }
5812 &Self::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE => {
5813 "DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE"
5814 }
5815 &Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM => {
5816 "PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM"
5817 }
5818 &Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM => {
5819 "PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM"
5820 }
5821 &Self::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM => {
5822 "SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM"
5823 }
5824 &Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => {
5825 "PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV"
5826 }
5827 &Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT => {
5828 "PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT"
5829 }
5830 &Self::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT => {
5831 "PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT"
5832 }
5833 &Self::RENDER_PASS_CREATION_CONTROL_EXT => {
5834 "RENDER_PASS_CREATION_CONTROL_EXT"
5835 }
5836 &Self::RENDER_PASS_CREATION_FEEDBACK_INFO_EXT => {
5837 "RENDER_PASS_CREATION_FEEDBACK_INFO_EXT"
5838 }
5839 &Self::RENDER_PASS_SUBPASS_FEEDBACK_INFO_EXT => {
5840 "RENDER_PASS_SUBPASS_FEEDBACK_INFO_EXT"
5841 }
5842 _ => "(unknown variant)",
5843 },
5844 )
5845 }
5846}
5847impl crate::vk1_0::StructureType {
5849 pub const APPLICATION_INFO: Self = Self(0);
5850 pub const INSTANCE_CREATE_INFO: Self = Self(1);
5851 pub const DEVICE_QUEUE_CREATE_INFO: Self = Self(2);
5852 pub const DEVICE_CREATE_INFO: Self = Self(3);
5853 pub const SUBMIT_INFO: Self = Self(4);
5854 pub const MEMORY_ALLOCATE_INFO: Self = Self(5);
5855 pub const MAPPED_MEMORY_RANGE: Self = Self(6);
5856 pub const BIND_SPARSE_INFO: Self = Self(7);
5857 pub const FENCE_CREATE_INFO: Self = Self(8);
5858 pub const SEMAPHORE_CREATE_INFO: Self = Self(9);
5859 pub const EVENT_CREATE_INFO: Self = Self(10);
5860 pub const QUERY_POOL_CREATE_INFO: Self = Self(11);
5861 pub const BUFFER_CREATE_INFO: Self = Self(12);
5862 pub const BUFFER_VIEW_CREATE_INFO: Self = Self(13);
5863 pub const IMAGE_CREATE_INFO: Self = Self(14);
5864 pub const IMAGE_VIEW_CREATE_INFO: Self = Self(15);
5865 pub const SHADER_MODULE_CREATE_INFO: Self = Self(16);
5866 pub const PIPELINE_CACHE_CREATE_INFO: Self = Self(17);
5867 pub const PIPELINE_SHADER_STAGE_CREATE_INFO: Self = Self(18);
5868 pub const PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: Self = Self(19);
5869 pub const PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: Self = Self(20);
5870 pub const PIPELINE_TESSELLATION_STATE_CREATE_INFO: Self = Self(21);
5871 pub const PIPELINE_VIEWPORT_STATE_CREATE_INFO: Self = Self(22);
5872 pub const PIPELINE_RASTERIZATION_STATE_CREATE_INFO: Self = Self(23);
5873 pub const PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: Self = Self(24);
5874 pub const PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: Self = Self(25);
5875 pub const PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: Self = Self(26);
5876 pub const PIPELINE_DYNAMIC_STATE_CREATE_INFO: Self = Self(27);
5877 pub const GRAPHICS_PIPELINE_CREATE_INFO: Self = Self(28);
5878 pub const COMPUTE_PIPELINE_CREATE_INFO: Self = Self(29);
5879 pub const PIPELINE_LAYOUT_CREATE_INFO: Self = Self(30);
5880 pub const SAMPLER_CREATE_INFO: Self = Self(31);
5881 pub const DESCRIPTOR_SET_LAYOUT_CREATE_INFO: Self = Self(32);
5882 pub const DESCRIPTOR_POOL_CREATE_INFO: Self = Self(33);
5883 pub const DESCRIPTOR_SET_ALLOCATE_INFO: Self = Self(34);
5884 pub const WRITE_DESCRIPTOR_SET: Self = Self(35);
5885 pub const COPY_DESCRIPTOR_SET: Self = Self(36);
5886 pub const FRAMEBUFFER_CREATE_INFO: Self = Self(37);
5887 pub const RENDER_PASS_CREATE_INFO: Self = Self(38);
5888 pub const COMMAND_POOL_CREATE_INFO: Self = Self(39);
5889 pub const COMMAND_BUFFER_ALLOCATE_INFO: Self = Self(40);
5890 pub const COMMAND_BUFFER_INHERITANCE_INFO: Self = Self(41);
5891 pub const COMMAND_BUFFER_BEGIN_INFO: Self = Self(42);
5892 pub const RENDER_PASS_BEGIN_INFO: Self = Self(43);
5893 pub const BUFFER_MEMORY_BARRIER: Self = Self(44);
5894 pub const IMAGE_MEMORY_BARRIER: Self = Self(45);
5895 pub const MEMORY_BARRIER: Self = Self(46);
5896 pub const LOADER_INSTANCE_CREATE_INFO: Self = Self(47);
5897 pub const LOADER_DEVICE_CREATE_INFO: Self = Self(48);
5898}
5899#[doc(alias = "VkSystemAllocationScope")]
5901#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
5902#[repr(transparent)]
5903pub struct SystemAllocationScope(pub i32);
5904impl std::fmt::Debug for SystemAllocationScope {
5905 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5906 f.write_str(
5907 match self {
5908 &Self::COMMAND => "COMMAND",
5909 &Self::OBJECT => "OBJECT",
5910 &Self::CACHE => "CACHE",
5911 &Self::DEVICE => "DEVICE",
5912 &Self::INSTANCE => "INSTANCE",
5913 _ => "(unknown variant)",
5914 },
5915 )
5916 }
5917}
5918impl crate::vk1_0::SystemAllocationScope {
5920 pub const COMMAND: Self = Self(0);
5921 pub const OBJECT: Self = Self(1);
5922 pub const CACHE: Self = Self(2);
5923 pub const DEVICE: Self = Self(3);
5924 pub const INSTANCE: Self = Self(4);
5925}
5926#[doc(alias = "VkInternalAllocationType")]
5928#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
5929#[repr(transparent)]
5930pub struct InternalAllocationType(pub i32);
5931impl std::fmt::Debug for InternalAllocationType {
5932 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5933 f.write_str(
5934 match self {
5935 &Self::EXECUTABLE => "EXECUTABLE",
5936 _ => "(unknown variant)",
5937 },
5938 )
5939 }
5940}
5941impl crate::vk1_0::InternalAllocationType {
5943 pub const EXECUTABLE: Self = Self(0);
5944}
5945#[doc(alias = "VkSamplerAddressMode")]
5947#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
5948#[repr(transparent)]
5949pub struct SamplerAddressMode(pub i32);
5950impl std::fmt::Debug for SamplerAddressMode {
5951 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5952 f.write_str(
5953 match self {
5954 &Self::REPEAT => "REPEAT",
5955 &Self::MIRRORED_REPEAT => "MIRRORED_REPEAT",
5956 &Self::CLAMP_TO_EDGE => "CLAMP_TO_EDGE",
5957 &Self::CLAMP_TO_BORDER => "CLAMP_TO_BORDER",
5958 &Self::MIRROR_CLAMP_TO_EDGE => "MIRROR_CLAMP_TO_EDGE",
5959 _ => "(unknown variant)",
5960 },
5961 )
5962 }
5963}
5964impl crate::vk1_0::SamplerAddressMode {
5966 pub const REPEAT: Self = Self(0);
5967 pub const MIRRORED_REPEAT: Self = Self(1);
5968 pub const CLAMP_TO_EDGE: Self = Self(2);
5969 pub const CLAMP_TO_BORDER: Self = Self(3);
5970}
5971#[doc(alias = "VkFilter")]
5973#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
5974#[repr(transparent)]
5975pub struct Filter(pub i32);
5976impl std::fmt::Debug for Filter {
5977 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
5978 f.write_str(
5979 match self {
5980 &Self::NEAREST => "NEAREST",
5981 &Self::LINEAR => "LINEAR",
5982 &Self::CUBIC_IMG => "CUBIC_IMG",
5983 _ => "(unknown variant)",
5984 },
5985 )
5986 }
5987}
5988impl crate::vk1_0::Filter {
5990 pub const NEAREST: Self = Self(0);
5991 pub const LINEAR: Self = Self(1);
5992}
5993#[doc(alias = "VkSamplerMipmapMode")]
5995#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
5996#[repr(transparent)]
5997pub struct SamplerMipmapMode(pub i32);
5998impl std::fmt::Debug for SamplerMipmapMode {
5999 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6000 f.write_str(
6001 match self {
6002 &Self::NEAREST => "NEAREST",
6003 &Self::LINEAR => "LINEAR",
6004 _ => "(unknown variant)",
6005 },
6006 )
6007 }
6008}
6009impl crate::vk1_0::SamplerMipmapMode {
6011 pub const NEAREST: Self = Self(0);
6012 pub const LINEAR: Self = Self(1);
6013}
6014#[doc(alias = "VkVertexInputRate")]
6016#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6017#[repr(transparent)]
6018pub struct VertexInputRate(pub i32);
6019impl std::fmt::Debug for VertexInputRate {
6020 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6021 f.write_str(
6022 match self {
6023 &Self::VERTEX => "VERTEX",
6024 &Self::INSTANCE => "INSTANCE",
6025 _ => "(unknown variant)",
6026 },
6027 )
6028 }
6029}
6030impl crate::vk1_0::VertexInputRate {
6032 pub const VERTEX: Self = Self(0);
6033 pub const INSTANCE: Self = Self(1);
6034}
6035bitflags::bitflags! {
6036 #[doc =
6037 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineStageFlags.html) · Bitmask of [`PipelineStageFlagBits`]"]
6038 #[doc(alias = "VkPipelineStageFlags")] #[derive(Default)] #[repr(transparent)] pub
6039 struct PipelineStageFlags : u32 { const TOP_OF_PIPE =
6040 PipelineStageFlagBits::TOP_OF_PIPE.0; const DRAW_INDIRECT =
6041 PipelineStageFlagBits::DRAW_INDIRECT.0; const VERTEX_INPUT =
6042 PipelineStageFlagBits::VERTEX_INPUT.0; const VERTEX_SHADER =
6043 PipelineStageFlagBits::VERTEX_SHADER.0; const TESSELLATION_CONTROL_SHADER =
6044 PipelineStageFlagBits::TESSELLATION_CONTROL_SHADER.0; const
6045 TESSELLATION_EVALUATION_SHADER =
6046 PipelineStageFlagBits::TESSELLATION_EVALUATION_SHADER.0; const GEOMETRY_SHADER =
6047 PipelineStageFlagBits::GEOMETRY_SHADER.0; const FRAGMENT_SHADER =
6048 PipelineStageFlagBits::FRAGMENT_SHADER.0; const EARLY_FRAGMENT_TESTS =
6049 PipelineStageFlagBits::EARLY_FRAGMENT_TESTS.0; const LATE_FRAGMENT_TESTS =
6050 PipelineStageFlagBits::LATE_FRAGMENT_TESTS.0; const COLOR_ATTACHMENT_OUTPUT =
6051 PipelineStageFlagBits::COLOR_ATTACHMENT_OUTPUT.0; const COMPUTE_SHADER =
6052 PipelineStageFlagBits::COMPUTE_SHADER.0; const TRANSFER =
6053 PipelineStageFlagBits::TRANSFER.0; const BOTTOM_OF_PIPE =
6054 PipelineStageFlagBits::BOTTOM_OF_PIPE.0; const HOST = PipelineStageFlagBits::HOST.0;
6055 const ALL_GRAPHICS = PipelineStageFlagBits::ALL_GRAPHICS.0; const ALL_COMMANDS =
6056 PipelineStageFlagBits::ALL_COMMANDS.0; const NONE = PipelineStageFlagBits::NONE.0;
6057 const TRANSFORM_FEEDBACK_EXT = PipelineStageFlagBits::TRANSFORM_FEEDBACK_EXT.0; const
6058 CONDITIONAL_RENDERING_EXT = PipelineStageFlagBits::CONDITIONAL_RENDERING_EXT.0; const
6059 ACCELERATION_STRUCTURE_BUILD_KHR =
6060 PipelineStageFlagBits::ACCELERATION_STRUCTURE_BUILD_KHR.0; const
6061 RAY_TRACING_SHADER_KHR = PipelineStageFlagBits::RAY_TRACING_SHADER_KHR.0; const
6062 TASK_SHADER_NV = PipelineStageFlagBits::TASK_SHADER_NV.0; const MESH_SHADER_NV =
6063 PipelineStageFlagBits::MESH_SHADER_NV.0; const FRAGMENT_DENSITY_PROCESS_EXT =
6064 PipelineStageFlagBits::FRAGMENT_DENSITY_PROCESS_EXT.0; const
6065 FRAGMENT_SHADING_RATE_ATTACHMENT_KHR =
6066 PipelineStageFlagBits::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0; const
6067 COMMAND_PREPROCESS_NV = PipelineStageFlagBits::COMMAND_PREPROCESS_NV.0; const
6068 SHADING_RATE_IMAGE_NV = PipelineStageFlagBits::SHADING_RATE_IMAGE_NV.0; const
6069 RAY_TRACING_SHADER_NV = PipelineStageFlagBits::RAY_TRACING_SHADER_NV.0; const
6070 ACCELERATION_STRUCTURE_BUILD_NV =
6071 PipelineStageFlagBits::ACCELERATION_STRUCTURE_BUILD_NV.0; const NONE_KHR =
6072 PipelineStageFlagBits::NONE_KHR.0; }
6073}
6074#[doc(alias = "VkPipelineStageFlagBits")]
6076#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6077#[repr(transparent)]
6078pub struct PipelineStageFlagBits(pub u32);
6079impl PipelineStageFlagBits {
6080 #[inline]
6081 pub const fn bitmask(&self) -> PipelineStageFlags {
6083 PipelineStageFlags::from_bits_truncate(self.0)
6084 }
6085}
6086impl std::fmt::Debug for PipelineStageFlagBits {
6087 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6088 f.write_str(
6089 match self {
6090 &Self::TOP_OF_PIPE => "TOP_OF_PIPE",
6091 &Self::DRAW_INDIRECT => "DRAW_INDIRECT",
6092 &Self::VERTEX_INPUT => "VERTEX_INPUT",
6093 &Self::VERTEX_SHADER => "VERTEX_SHADER",
6094 &Self::TESSELLATION_CONTROL_SHADER => "TESSELLATION_CONTROL_SHADER",
6095 &Self::TESSELLATION_EVALUATION_SHADER => "TESSELLATION_EVALUATION_SHADER",
6096 &Self::GEOMETRY_SHADER => "GEOMETRY_SHADER",
6097 &Self::FRAGMENT_SHADER => "FRAGMENT_SHADER",
6098 &Self::EARLY_FRAGMENT_TESTS => "EARLY_FRAGMENT_TESTS",
6099 &Self::LATE_FRAGMENT_TESTS => "LATE_FRAGMENT_TESTS",
6100 &Self::COLOR_ATTACHMENT_OUTPUT => "COLOR_ATTACHMENT_OUTPUT",
6101 &Self::COMPUTE_SHADER => "COMPUTE_SHADER",
6102 &Self::TRANSFER => "TRANSFER",
6103 &Self::BOTTOM_OF_PIPE => "BOTTOM_OF_PIPE",
6104 &Self::HOST => "HOST",
6105 &Self::ALL_GRAPHICS => "ALL_GRAPHICS",
6106 &Self::ALL_COMMANDS => "ALL_COMMANDS",
6107 &Self::NONE => "NONE",
6108 &Self::TRANSFORM_FEEDBACK_EXT => "TRANSFORM_FEEDBACK_EXT",
6109 &Self::CONDITIONAL_RENDERING_EXT => "CONDITIONAL_RENDERING_EXT",
6110 &Self::ACCELERATION_STRUCTURE_BUILD_KHR => {
6111 "ACCELERATION_STRUCTURE_BUILD_KHR"
6112 }
6113 &Self::RAY_TRACING_SHADER_KHR => "RAY_TRACING_SHADER_KHR",
6114 &Self::TASK_SHADER_NV => "TASK_SHADER_NV",
6115 &Self::MESH_SHADER_NV => "MESH_SHADER_NV",
6116 &Self::FRAGMENT_DENSITY_PROCESS_EXT => "FRAGMENT_DENSITY_PROCESS_EXT",
6117 &Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR => {
6118 "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR"
6119 }
6120 &Self::COMMAND_PREPROCESS_NV => "COMMAND_PREPROCESS_NV",
6121 _ => "(unknown variant)",
6122 },
6123 )
6124 }
6125}
6126impl crate::vk1_0::PipelineStageFlagBits {
6128 pub const TOP_OF_PIPE: Self = Self(1);
6129 pub const DRAW_INDIRECT: Self = Self(2);
6130 pub const VERTEX_INPUT: Self = Self(4);
6131 pub const VERTEX_SHADER: Self = Self(8);
6132 pub const TESSELLATION_CONTROL_SHADER: Self = Self(16);
6133 pub const TESSELLATION_EVALUATION_SHADER: Self = Self(32);
6134 pub const GEOMETRY_SHADER: Self = Self(64);
6135 pub const FRAGMENT_SHADER: Self = Self(128);
6136 pub const EARLY_FRAGMENT_TESTS: Self = Self(256);
6137 pub const LATE_FRAGMENT_TESTS: Self = Self(512);
6138 pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(1024);
6139 pub const COMPUTE_SHADER: Self = Self(2048);
6140 pub const TRANSFER: Self = Self(4096);
6141 pub const BOTTOM_OF_PIPE: Self = Self(8192);
6142 pub const HOST: Self = Self(16384);
6143 pub const ALL_GRAPHICS: Self = Self(32768);
6144 pub const ALL_COMMANDS: Self = Self(65536);
6145}
6146bitflags::bitflags! {
6147 #[doc =
6148 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatFlags.html) · Bitmask of [`SparseImageFormatFlagBits`]"]
6149 #[doc(alias = "VkSparseImageFormatFlags")] #[derive(Default)] #[repr(transparent)]
6150 pub struct SparseImageFormatFlags : u32 { const SINGLE_MIPTAIL =
6151 SparseImageFormatFlagBits::SINGLE_MIPTAIL.0; const ALIGNED_MIP_SIZE =
6152 SparseImageFormatFlagBits::ALIGNED_MIP_SIZE.0; const NONSTANDARD_BLOCK_SIZE =
6153 SparseImageFormatFlagBits::NONSTANDARD_BLOCK_SIZE.0; }
6154}
6155#[doc(alias = "VkSparseImageFormatFlagBits")]
6157#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6158#[repr(transparent)]
6159pub struct SparseImageFormatFlagBits(pub u32);
6160impl SparseImageFormatFlagBits {
6161 #[inline]
6162 pub const fn bitmask(&self) -> SparseImageFormatFlags {
6164 SparseImageFormatFlags::from_bits_truncate(self.0)
6165 }
6166}
6167impl std::fmt::Debug for SparseImageFormatFlagBits {
6168 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6169 f.write_str(
6170 match self {
6171 &Self::SINGLE_MIPTAIL => "SINGLE_MIPTAIL",
6172 &Self::ALIGNED_MIP_SIZE => "ALIGNED_MIP_SIZE",
6173 &Self::NONSTANDARD_BLOCK_SIZE => "NONSTANDARD_BLOCK_SIZE",
6174 _ => "(unknown variant)",
6175 },
6176 )
6177 }
6178}
6179impl crate::vk1_0::SparseImageFormatFlagBits {
6181 pub const SINGLE_MIPTAIL: Self = Self(1);
6182 pub const ALIGNED_MIP_SIZE: Self = Self(2);
6183 pub const NONSTANDARD_BLOCK_SIZE: Self = Self(4);
6184}
6185bitflags::bitflags! {
6186 #[doc =
6187 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleCountFlags.html) · Bitmask of [`SampleCountFlagBits`]"]
6188 #[doc(alias = "VkSampleCountFlags")] #[derive(Default)] #[repr(transparent)] pub
6189 struct SampleCountFlags : u32 { const _1 = SampleCountFlagBits::_1.0; const _2 =
6190 SampleCountFlagBits::_2.0; const _4 = SampleCountFlagBits::_4.0; const _8 =
6191 SampleCountFlagBits::_8.0; const _16 = SampleCountFlagBits::_16.0; const _32 =
6192 SampleCountFlagBits::_32.0; const _64 = SampleCountFlagBits::_64.0; }
6193}
6194#[doc(alias = "VkSampleCountFlagBits")]
6196#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6197#[repr(transparent)]
6198pub struct SampleCountFlagBits(pub u32);
6199impl SampleCountFlagBits {
6200 #[inline]
6201 pub const fn bitmask(&self) -> SampleCountFlags {
6203 SampleCountFlags::from_bits_truncate(self.0)
6204 }
6205}
6206impl std::fmt::Debug for SampleCountFlagBits {
6207 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6208 f.write_str(
6209 match self {
6210 &Self::_1 => "1",
6211 &Self::_2 => "2",
6212 &Self::_4 => "4",
6213 &Self::_8 => "8",
6214 &Self::_16 => "16",
6215 &Self::_32 => "32",
6216 &Self::_64 => "64",
6217 _ => "(unknown variant)",
6218 },
6219 )
6220 }
6221}
6222impl crate::vk1_0::SampleCountFlagBits {
6224 pub const _1: Self = Self(1);
6225 pub const _2: Self = Self(2);
6226 pub const _4: Self = Self(4);
6227 pub const _8: Self = Self(8);
6228 pub const _16: Self = Self(16);
6229 pub const _32: Self = Self(32);
6230 pub const _64: Self = Self(64);
6231}
6232bitflags::bitflags! {
6233 #[doc =
6234 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionFlags.html) · Bitmask of [`AttachmentDescriptionFlagBits`]"]
6235 #[doc(alias = "VkAttachmentDescriptionFlags")] #[derive(Default)]
6236 #[repr(transparent)] pub struct AttachmentDescriptionFlags : u32 { const MAY_ALIAS =
6237 AttachmentDescriptionFlagBits::MAY_ALIAS.0; }
6238}
6239#[doc(alias = "VkAttachmentDescriptionFlagBits")]
6241#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6242#[repr(transparent)]
6243pub struct AttachmentDescriptionFlagBits(pub u32);
6244impl AttachmentDescriptionFlagBits {
6245 #[inline]
6246 pub const fn bitmask(&self) -> AttachmentDescriptionFlags {
6248 AttachmentDescriptionFlags::from_bits_truncate(self.0)
6249 }
6250}
6251impl std::fmt::Debug for AttachmentDescriptionFlagBits {
6252 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6253 f.write_str(
6254 match self {
6255 &Self::MAY_ALIAS => "MAY_ALIAS",
6256 _ => "(unknown variant)",
6257 },
6258 )
6259 }
6260}
6261impl crate::vk1_0::AttachmentDescriptionFlagBits {
6263 pub const MAY_ALIAS: Self = Self(1);
6264}
6265bitflags::bitflags! {
6266 #[doc =
6267 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateFlags.html) · Bitmask of [`DescriptorPoolCreateFlagBits`]"]
6268 #[doc(alias = "VkDescriptorPoolCreateFlags")] #[derive(Default)] #[repr(transparent)]
6269 pub struct DescriptorPoolCreateFlags : u32 { const FREE_DESCRIPTOR_SET =
6270 DescriptorPoolCreateFlagBits::FREE_DESCRIPTOR_SET.0; const UPDATE_AFTER_BIND =
6271 DescriptorPoolCreateFlagBits::UPDATE_AFTER_BIND.0; const HOST_ONLY_VALVE =
6272 DescriptorPoolCreateFlagBits::HOST_ONLY_VALVE.0; const UPDATE_AFTER_BIND_EXT =
6273 DescriptorPoolCreateFlagBits::UPDATE_AFTER_BIND_EXT.0; }
6274}
6275#[doc(alias = "VkDescriptorPoolCreateFlagBits")]
6277#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6278#[repr(transparent)]
6279pub struct DescriptorPoolCreateFlagBits(pub u32);
6280impl DescriptorPoolCreateFlagBits {
6281 #[inline]
6282 pub const fn bitmask(&self) -> DescriptorPoolCreateFlags {
6284 DescriptorPoolCreateFlags::from_bits_truncate(self.0)
6285 }
6286}
6287impl std::fmt::Debug for DescriptorPoolCreateFlagBits {
6288 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6289 f.write_str(
6290 match self {
6291 &Self::FREE_DESCRIPTOR_SET => "FREE_DESCRIPTOR_SET",
6292 &Self::UPDATE_AFTER_BIND => "UPDATE_AFTER_BIND",
6293 &Self::HOST_ONLY_VALVE => "HOST_ONLY_VALVE",
6294 _ => "(unknown variant)",
6295 },
6296 )
6297 }
6298}
6299impl crate::vk1_0::DescriptorPoolCreateFlagBits {
6301 pub const FREE_DESCRIPTOR_SET: Self = Self(1);
6302}
6303bitflags::bitflags! {
6304 #[doc =
6305 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyFlags.html) · Bitmask of [`DependencyFlagBits`]"]
6306 #[doc(alias = "VkDependencyFlags")] #[derive(Default)] #[repr(transparent)] pub
6307 struct DependencyFlags : u32 { const BY_REGION = DependencyFlagBits::BY_REGION.0;
6308 const DEVICE_GROUP = DependencyFlagBits::DEVICE_GROUP.0; const VIEW_LOCAL =
6309 DependencyFlagBits::VIEW_LOCAL.0; const VIEW_LOCAL_KHR =
6310 DependencyFlagBits::VIEW_LOCAL_KHR.0; const DEVICE_GROUP_KHR =
6311 DependencyFlagBits::DEVICE_GROUP_KHR.0; }
6312}
6313#[doc(alias = "VkDependencyFlagBits")]
6315#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6316#[repr(transparent)]
6317pub struct DependencyFlagBits(pub u32);
6318impl DependencyFlagBits {
6319 #[inline]
6320 pub const fn bitmask(&self) -> DependencyFlags {
6322 DependencyFlags::from_bits_truncate(self.0)
6323 }
6324}
6325impl std::fmt::Debug for DependencyFlagBits {
6326 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6327 f.write_str(
6328 match self {
6329 &Self::BY_REGION => "BY_REGION",
6330 &Self::DEVICE_GROUP => "DEVICE_GROUP",
6331 &Self::VIEW_LOCAL => "VIEW_LOCAL",
6332 _ => "(unknown variant)",
6333 },
6334 )
6335 }
6336}
6337impl crate::vk1_0::DependencyFlagBits {
6339 pub const BY_REGION: Self = Self(1);
6340}
6341#[doc(alias = "VkObjectType")]
6343#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6344#[repr(transparent)]
6345pub struct ObjectType(pub i32);
6346impl std::fmt::Debug for ObjectType {
6347 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6348 f.write_str(
6349 match self {
6350 &Self::UNKNOWN => "UNKNOWN",
6351 &Self::INSTANCE => "INSTANCE",
6352 &Self::PHYSICAL_DEVICE => "PHYSICAL_DEVICE",
6353 &Self::DEVICE => "DEVICE",
6354 &Self::QUEUE => "QUEUE",
6355 &Self::SEMAPHORE => "SEMAPHORE",
6356 &Self::COMMAND_BUFFER => "COMMAND_BUFFER",
6357 &Self::FENCE => "FENCE",
6358 &Self::DEVICE_MEMORY => "DEVICE_MEMORY",
6359 &Self::BUFFER => "BUFFER",
6360 &Self::IMAGE => "IMAGE",
6361 &Self::EVENT => "EVENT",
6362 &Self::QUERY_POOL => "QUERY_POOL",
6363 &Self::BUFFER_VIEW => "BUFFER_VIEW",
6364 &Self::IMAGE_VIEW => "IMAGE_VIEW",
6365 &Self::SHADER_MODULE => "SHADER_MODULE",
6366 &Self::PIPELINE_CACHE => "PIPELINE_CACHE",
6367 &Self::PIPELINE_LAYOUT => "PIPELINE_LAYOUT",
6368 &Self::RENDER_PASS => "RENDER_PASS",
6369 &Self::PIPELINE => "PIPELINE",
6370 &Self::DESCRIPTOR_SET_LAYOUT => "DESCRIPTOR_SET_LAYOUT",
6371 &Self::SAMPLER => "SAMPLER",
6372 &Self::DESCRIPTOR_POOL => "DESCRIPTOR_POOL",
6373 &Self::DESCRIPTOR_SET => "DESCRIPTOR_SET",
6374 &Self::FRAMEBUFFER => "FRAMEBUFFER",
6375 &Self::COMMAND_POOL => "COMMAND_POOL",
6376 &Self::SAMPLER_YCBCR_CONVERSION => "SAMPLER_YCBCR_CONVERSION",
6377 &Self::DESCRIPTOR_UPDATE_TEMPLATE => "DESCRIPTOR_UPDATE_TEMPLATE",
6378 &Self::PRIVATE_DATA_SLOT => "PRIVATE_DATA_SLOT",
6379 &Self::SURFACE_KHR => "SURFACE_KHR",
6380 &Self::SWAPCHAIN_KHR => "SWAPCHAIN_KHR",
6381 &Self::DISPLAY_KHR => "DISPLAY_KHR",
6382 &Self::DISPLAY_MODE_KHR => "DISPLAY_MODE_KHR",
6383 &Self::DEBUG_REPORT_CALLBACK_EXT => "DEBUG_REPORT_CALLBACK_EXT",
6384 &Self::VIDEO_SESSION_KHR => "VIDEO_SESSION_KHR",
6385 &Self::VIDEO_SESSION_PARAMETERS_KHR => "VIDEO_SESSION_PARAMETERS_KHR",
6386 &Self::CU_MODULE_NVX => "CU_MODULE_NVX",
6387 &Self::CU_FUNCTION_NVX => "CU_FUNCTION_NVX",
6388 &Self::DEBUG_UTILS_MESSENGER_EXT => "DEBUG_UTILS_MESSENGER_EXT",
6389 &Self::ACCELERATION_STRUCTURE_KHR => "ACCELERATION_STRUCTURE_KHR",
6390 &Self::VALIDATION_CACHE_EXT => "VALIDATION_CACHE_EXT",
6391 &Self::ACCELERATION_STRUCTURE_NV => "ACCELERATION_STRUCTURE_NV",
6392 &Self::PERFORMANCE_CONFIGURATION_INTEL => {
6393 "PERFORMANCE_CONFIGURATION_INTEL"
6394 }
6395 &Self::DEFERRED_OPERATION_KHR => "DEFERRED_OPERATION_KHR",
6396 &Self::INDIRECT_COMMANDS_LAYOUT_NV => "INDIRECT_COMMANDS_LAYOUT_NV",
6397 &Self::BUFFER_COLLECTION_FUCHSIA => "BUFFER_COLLECTION_FUCHSIA",
6398 _ => "(unknown variant)",
6399 },
6400 )
6401 }
6402}
6403impl crate::vk1_0::ObjectType {
6405 pub const UNKNOWN: Self = Self(0);
6406 pub const INSTANCE: Self = Self(1);
6407 pub const PHYSICAL_DEVICE: Self = Self(2);
6408 pub const DEVICE: Self = Self(3);
6409 pub const QUEUE: Self = Self(4);
6410 pub const SEMAPHORE: Self = Self(5);
6411 pub const COMMAND_BUFFER: Self = Self(6);
6412 pub const FENCE: Self = Self(7);
6413 pub const DEVICE_MEMORY: Self = Self(8);
6414 pub const BUFFER: Self = Self(9);
6415 pub const IMAGE: Self = Self(10);
6416 pub const EVENT: Self = Self(11);
6417 pub const QUERY_POOL: Self = Self(12);
6418 pub const BUFFER_VIEW: Self = Self(13);
6419 pub const IMAGE_VIEW: Self = Self(14);
6420 pub const SHADER_MODULE: Self = Self(15);
6421 pub const PIPELINE_CACHE: Self = Self(16);
6422 pub const PIPELINE_LAYOUT: Self = Self(17);
6423 pub const RENDER_PASS: Self = Self(18);
6424 pub const PIPELINE: Self = Self(19);
6425 pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20);
6426 pub const SAMPLER: Self = Self(21);
6427 pub const DESCRIPTOR_POOL: Self = Self(22);
6428 pub const DESCRIPTOR_SET: Self = Self(23);
6429 pub const FRAMEBUFFER: Self = Self(24);
6430 pub const COMMAND_POOL: Self = Self(25);
6431}
6432bitflags::bitflags! {
6433 #[doc =
6434 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateFlags.html) · Bitmask of [`EventCreateFlagBits`]"]
6435 #[doc(alias = "VkEventCreateFlags")] #[derive(Default)] #[repr(transparent)] pub
6436 struct EventCreateFlags : u32 { const DEVICE_ONLY = EventCreateFlagBits::DEVICE_ONLY
6437 .0; const DEVICE_ONLY_KHR = EventCreateFlagBits::DEVICE_ONLY_KHR.0; }
6438}
6439#[doc(alias = "VkEventCreateFlagBits")]
6441#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6442#[repr(transparent)]
6443pub struct EventCreateFlagBits(pub u32);
6444impl EventCreateFlagBits {
6445 #[inline]
6446 pub const fn bitmask(&self) -> EventCreateFlags {
6448 EventCreateFlags::from_bits_truncate(self.0)
6449 }
6450}
6451impl std::fmt::Debug for EventCreateFlagBits {
6452 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6453 f.write_str(
6454 match self {
6455 &Self::DEVICE_ONLY => "DEVICE_ONLY",
6456 _ => "(unknown variant)",
6457 },
6458 )
6459 }
6460}
6461bitflags::bitflags! {
6462 #[doc =
6463 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateFlags.html) · Bitmask of [`PipelineLayoutCreateFlagBits`]"]
6464 #[doc(alias = "VkPipelineLayoutCreateFlags")] #[derive(Default)] #[repr(transparent)]
6465 pub struct PipelineLayoutCreateFlags : u32 { const INDEPENDENT_SETS_EXT =
6466 PipelineLayoutCreateFlagBits::INDEPENDENT_SETS_EXT.0; }
6467}
6468#[doc(alias = "VkPipelineLayoutCreateFlagBits")]
6470#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6471#[repr(transparent)]
6472pub struct PipelineLayoutCreateFlagBits(pub u32);
6473impl PipelineLayoutCreateFlagBits {
6474 #[inline]
6475 pub const fn bitmask(&self) -> PipelineLayoutCreateFlags {
6477 PipelineLayoutCreateFlags::from_bits_truncate(self.0)
6478 }
6479}
6480impl std::fmt::Debug for PipelineLayoutCreateFlagBits {
6481 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6482 f.write_str(
6483 match self {
6484 &Self::INDEPENDENT_SETS_EXT => "INDEPENDENT_SETS_EXT",
6485 _ => "(unknown variant)",
6486 },
6487 )
6488 }
6489}
6490bitflags::bitflags! {
6491 #[doc =
6492 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionFlags.html) · Bitmask of [`SubpassDescriptionFlagBits`]"]
6493 #[doc(alias = "VkSubpassDescriptionFlags")] #[derive(Default)] #[repr(transparent)]
6494 pub struct SubpassDescriptionFlags : u32 { const PER_VIEW_ATTRIBUTES_NVX =
6495 SubpassDescriptionFlagBits::PER_VIEW_ATTRIBUTES_NVX.0; const
6496 PER_VIEW_POSITION_X_ONLY_NVX =
6497 SubpassDescriptionFlagBits::PER_VIEW_POSITION_X_ONLY_NVX.0; const
6498 FRAGMENT_REGION_QCOM = SubpassDescriptionFlagBits::FRAGMENT_REGION_QCOM.0; const
6499 SHADER_RESOLVE_QCOM = SubpassDescriptionFlagBits::SHADER_RESOLVE_QCOM.0; const
6500 RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM =
6501 SubpassDescriptionFlagBits::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM.0; const
6502 RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM =
6503 SubpassDescriptionFlagBits::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM.0; const
6504 RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM =
6505 SubpassDescriptionFlagBits::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM.0; }
6506}
6507#[doc(alias = "VkSubpassDescriptionFlagBits")]
6509#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6510#[repr(transparent)]
6511pub struct SubpassDescriptionFlagBits(pub u32);
6512impl SubpassDescriptionFlagBits {
6513 #[inline]
6514 pub const fn bitmask(&self) -> SubpassDescriptionFlags {
6516 SubpassDescriptionFlags::from_bits_truncate(self.0)
6517 }
6518}
6519impl std::fmt::Debug for SubpassDescriptionFlagBits {
6520 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6521 f.write_str(
6522 match self {
6523 &Self::PER_VIEW_ATTRIBUTES_NVX => "PER_VIEW_ATTRIBUTES_NVX",
6524 &Self::PER_VIEW_POSITION_X_ONLY_NVX => "PER_VIEW_POSITION_X_ONLY_NVX",
6525 &Self::FRAGMENT_REGION_QCOM => "FRAGMENT_REGION_QCOM",
6526 &Self::SHADER_RESOLVE_QCOM => "SHADER_RESOLVE_QCOM",
6527 &Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM => {
6528 "RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM"
6529 }
6530 &Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM => {
6531 "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM"
6532 }
6533 &Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM => {
6534 "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM"
6535 }
6536 _ => "(unknown variant)",
6537 },
6538 )
6539 }
6540}
6541bitflags::bitflags! {
6542 #[doc =
6543 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateFlags.html) · Bitmask of [`PipelineDepthStencilStateCreateFlagBits`]"]
6544 #[doc(alias = "VkPipelineDepthStencilStateCreateFlags")] #[derive(Default)]
6545 #[repr(transparent)] pub struct PipelineDepthStencilStateCreateFlags : u32 { const
6546 RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM =
6547 PipelineDepthStencilStateCreateFlagBits::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM
6548 .0; const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM =
6549 PipelineDepthStencilStateCreateFlagBits::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM
6550 .0; }
6551}
6552#[doc(alias = "VkPipelineDepthStencilStateCreateFlagBits")]
6554#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6555#[repr(transparent)]
6556pub struct PipelineDepthStencilStateCreateFlagBits(pub u32);
6557impl PipelineDepthStencilStateCreateFlagBits {
6558 #[inline]
6559 pub const fn bitmask(&self) -> PipelineDepthStencilStateCreateFlags {
6561 PipelineDepthStencilStateCreateFlags::from_bits_truncate(self.0)
6562 }
6563}
6564impl std::fmt::Debug for PipelineDepthStencilStateCreateFlagBits {
6565 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6566 f.write_str(
6567 match self {
6568 &Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM => {
6569 "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM"
6570 }
6571 &Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM => {
6572 "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM"
6573 }
6574 _ => "(unknown variant)",
6575 },
6576 )
6577 }
6578}
6579bitflags::bitflags! {
6580 #[doc =
6581 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateFlags.html) · Bitmask of [`PipelineColorBlendStateCreateFlagBits`]"]
6582 #[doc(alias = "VkPipelineColorBlendStateCreateFlags")] #[derive(Default)]
6583 #[repr(transparent)] pub struct PipelineColorBlendStateCreateFlags : u32 { const
6584 RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM =
6585 PipelineColorBlendStateCreateFlagBits::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM.0; }
6586}
6587#[doc(alias = "VkPipelineColorBlendStateCreateFlagBits")]
6589#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6590#[repr(transparent)]
6591pub struct PipelineColorBlendStateCreateFlagBits(pub u32);
6592impl PipelineColorBlendStateCreateFlagBits {
6593 #[inline]
6594 pub const fn bitmask(&self) -> PipelineColorBlendStateCreateFlags {
6596 PipelineColorBlendStateCreateFlags::from_bits_truncate(self.0)
6597 }
6598}
6599impl std::fmt::Debug for PipelineColorBlendStateCreateFlagBits {
6600 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6601 f.write_str(
6602 match self {
6603 &Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM => {
6604 "RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM"
6605 }
6606 _ => "(unknown variant)",
6607 },
6608 )
6609 }
6610}
6611#[doc(alias = "VkVendorId")]
6613#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
6614#[repr(transparent)]
6615pub struct VendorId(pub i32);
6616impl std::fmt::Debug for VendorId {
6617 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
6618 f.write_str(
6619 match self {
6620 &Self::VIV => "VIV",
6621 &Self::VSI => "VSI",
6622 &Self::KAZAN => "KAZAN",
6623 &Self::CODEPLAY => "CODEPLAY",
6624 &Self::MESA => "MESA",
6625 &Self::POCL => "POCL",
6626 _ => "(unknown variant)",
6627 },
6628 )
6629 }
6630}
6631impl crate::vk1_0::VendorId {
6633 pub const VIV: Self = Self(65537);
6634 pub const VSI: Self = Self(65538);
6635 pub const KAZAN: Self = Self(65539);
6636 pub const CODEPLAY: Self = Self(65540);
6637 pub const MESA: Self = Self(65541);
6638 pub const POCL: Self = Self(65542);
6639}
6640#[allow(non_camel_case_types)]
6642pub type PFN_vkCreateInstance = unsafe extern "system" fn(
6643 p_create_info: *const crate::vk1_0::InstanceCreateInfo,
6644 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6645 p_instance: *mut crate::vk1_0::Instance,
6646) -> crate::vk1_0::Result;
6647#[allow(non_camel_case_types)]
6649pub type PFN_vkDestroyInstance = unsafe extern "system" fn(
6650 instance: crate::vk1_0::Instance,
6651 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6652) -> ();
6653#[allow(non_camel_case_types)]
6655pub type PFN_vkEnumeratePhysicalDevices = unsafe extern "system" fn(
6656 instance: crate::vk1_0::Instance,
6657 p_physical_device_count: *mut u32,
6658 p_physical_devices: *mut crate::vk1_0::PhysicalDevice,
6659) -> crate::vk1_0::Result;
6660#[allow(non_camel_case_types)]
6662pub type PFN_vkGetDeviceProcAddr = unsafe extern "system" fn(
6663 device: crate::vk1_0::Device,
6664 p_name: *const std::os::raw::c_char,
6665) -> Option<crate::vk1_0::PFN_vkVoidFunction>;
6666#[allow(non_camel_case_types)]
6668pub type PFN_vkGetInstanceProcAddr = unsafe extern "system" fn(
6669 instance: crate::vk1_0::Instance,
6670 p_name: *const std::os::raw::c_char,
6671) -> Option<crate::vk1_0::PFN_vkVoidFunction>;
6672#[allow(non_camel_case_types)]
6674pub type PFN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn(
6675 physical_device: crate::vk1_0::PhysicalDevice,
6676 p_properties: *mut crate::vk1_0::PhysicalDeviceProperties,
6677) -> ();
6678#[allow(non_camel_case_types)]
6680pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn(
6681 physical_device: crate::vk1_0::PhysicalDevice,
6682 p_queue_family_property_count: *mut u32,
6683 p_queue_family_properties: *mut crate::vk1_0::QueueFamilyProperties,
6684) -> ();
6685#[allow(non_camel_case_types)]
6687pub type PFN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn(
6688 physical_device: crate::vk1_0::PhysicalDevice,
6689 p_memory_properties: *mut crate::vk1_0::PhysicalDeviceMemoryProperties,
6690) -> ();
6691#[allow(non_camel_case_types)]
6693pub type PFN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn(
6694 physical_device: crate::vk1_0::PhysicalDevice,
6695 p_features: *mut crate::vk1_0::PhysicalDeviceFeatures,
6696) -> ();
6697#[allow(non_camel_case_types)]
6699pub type PFN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn(
6700 physical_device: crate::vk1_0::PhysicalDevice,
6701 format: crate::vk1_0::Format,
6702 p_format_properties: *mut crate::vk1_0::FormatProperties,
6703) -> ();
6704#[allow(non_camel_case_types)]
6706pub type PFN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn(
6707 physical_device: crate::vk1_0::PhysicalDevice,
6708 format: crate::vk1_0::Format,
6709 _type: crate::vk1_0::ImageType,
6710 tiling: crate::vk1_0::ImageTiling,
6711 usage: crate::vk1_0::ImageUsageFlags,
6712 flags: crate::vk1_0::ImageCreateFlags,
6713 p_image_format_properties: *mut crate::vk1_0::ImageFormatProperties,
6714) -> crate::vk1_0::Result;
6715#[allow(non_camel_case_types)]
6717pub type PFN_vkCreateDevice = unsafe extern "system" fn(
6718 physical_device: crate::vk1_0::PhysicalDevice,
6719 p_create_info: *const crate::vk1_0::DeviceCreateInfo,
6720 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6721 p_device: *mut crate::vk1_0::Device,
6722) -> crate::vk1_0::Result;
6723#[allow(non_camel_case_types)]
6725pub type PFN_vkDestroyDevice = unsafe extern "system" fn(
6726 device: crate::vk1_0::Device,
6727 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6728) -> ();
6729#[allow(non_camel_case_types)]
6731pub type PFN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn(
6732 p_property_count: *mut u32,
6733 p_properties: *mut crate::vk1_0::LayerProperties,
6734) -> crate::vk1_0::Result;
6735#[allow(non_camel_case_types)]
6737pub type PFN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn(
6738 p_layer_name: *const std::os::raw::c_char,
6739 p_property_count: *mut u32,
6740 p_properties: *mut crate::vk1_0::ExtensionProperties,
6741) -> crate::vk1_0::Result;
6742#[allow(non_camel_case_types)]
6744pub type PFN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn(
6745 physical_device: crate::vk1_0::PhysicalDevice,
6746 p_property_count: *mut u32,
6747 p_properties: *mut crate::vk1_0::LayerProperties,
6748) -> crate::vk1_0::Result;
6749#[allow(non_camel_case_types)]
6751pub type PFN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn(
6752 physical_device: crate::vk1_0::PhysicalDevice,
6753 p_layer_name: *const std::os::raw::c_char,
6754 p_property_count: *mut u32,
6755 p_properties: *mut crate::vk1_0::ExtensionProperties,
6756) -> crate::vk1_0::Result;
6757#[allow(non_camel_case_types)]
6759pub type PFN_vkGetDeviceQueue = unsafe extern "system" fn(
6760 device: crate::vk1_0::Device,
6761 queue_family_index: u32,
6762 queue_index: u32,
6763 p_queue: *mut crate::vk1_0::Queue,
6764) -> ();
6765#[allow(non_camel_case_types)]
6767pub type PFN_vkQueueSubmit = unsafe extern "system" fn(
6768 queue: crate::vk1_0::Queue,
6769 submit_count: u32,
6770 p_submits: *const crate::vk1_0::SubmitInfo,
6771 fence: crate::vk1_0::Fence,
6772) -> crate::vk1_0::Result;
6773#[allow(non_camel_case_types)]
6775pub type PFN_vkQueueWaitIdle = unsafe extern "system" fn(
6776 queue: crate::vk1_0::Queue,
6777) -> crate::vk1_0::Result;
6778#[allow(non_camel_case_types)]
6780pub type PFN_vkDeviceWaitIdle = unsafe extern "system" fn(
6781 device: crate::vk1_0::Device,
6782) -> crate::vk1_0::Result;
6783#[allow(non_camel_case_types)]
6785pub type PFN_vkAllocateMemory = unsafe extern "system" fn(
6786 device: crate::vk1_0::Device,
6787 p_allocate_info: *const crate::vk1_0::MemoryAllocateInfo,
6788 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6789 p_memory: *mut crate::vk1_0::DeviceMemory,
6790) -> crate::vk1_0::Result;
6791#[allow(non_camel_case_types)]
6793pub type PFN_vkFreeMemory = unsafe extern "system" fn(
6794 device: crate::vk1_0::Device,
6795 memory: crate::vk1_0::DeviceMemory,
6796 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6797) -> ();
6798#[allow(non_camel_case_types)]
6800pub type PFN_vkMapMemory = unsafe extern "system" fn(
6801 device: crate::vk1_0::Device,
6802 memory: crate::vk1_0::DeviceMemory,
6803 offset: crate::vk1_0::DeviceSize,
6804 size: crate::vk1_0::DeviceSize,
6805 flags: crate::vk1_0::MemoryMapFlags,
6806 pp_data: *mut *mut std::ffi::c_void,
6807) -> crate::vk1_0::Result;
6808#[allow(non_camel_case_types)]
6810pub type PFN_vkUnmapMemory = unsafe extern "system" fn(
6811 device: crate::vk1_0::Device,
6812 memory: crate::vk1_0::DeviceMemory,
6813) -> ();
6814#[allow(non_camel_case_types)]
6816pub type PFN_vkFlushMappedMemoryRanges = unsafe extern "system" fn(
6817 device: crate::vk1_0::Device,
6818 memory_range_count: u32,
6819 p_memory_ranges: *const crate::vk1_0::MappedMemoryRange,
6820) -> crate::vk1_0::Result;
6821#[allow(non_camel_case_types)]
6823pub type PFN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn(
6824 device: crate::vk1_0::Device,
6825 memory_range_count: u32,
6826 p_memory_ranges: *const crate::vk1_0::MappedMemoryRange,
6827) -> crate::vk1_0::Result;
6828#[allow(non_camel_case_types)]
6830pub type PFN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn(
6831 device: crate::vk1_0::Device,
6832 memory: crate::vk1_0::DeviceMemory,
6833 p_committed_memory_in_bytes: *mut crate::vk1_0::DeviceSize,
6834) -> ();
6835#[allow(non_camel_case_types)]
6837pub type PFN_vkGetBufferMemoryRequirements = unsafe extern "system" fn(
6838 device: crate::vk1_0::Device,
6839 buffer: crate::vk1_0::Buffer,
6840 p_memory_requirements: *mut crate::vk1_0::MemoryRequirements,
6841) -> ();
6842#[allow(non_camel_case_types)]
6844pub type PFN_vkBindBufferMemory = unsafe extern "system" fn(
6845 device: crate::vk1_0::Device,
6846 buffer: crate::vk1_0::Buffer,
6847 memory: crate::vk1_0::DeviceMemory,
6848 memory_offset: crate::vk1_0::DeviceSize,
6849) -> crate::vk1_0::Result;
6850#[allow(non_camel_case_types)]
6852pub type PFN_vkGetImageMemoryRequirements = unsafe extern "system" fn(
6853 device: crate::vk1_0::Device,
6854 image: crate::vk1_0::Image,
6855 p_memory_requirements: *mut crate::vk1_0::MemoryRequirements,
6856) -> ();
6857#[allow(non_camel_case_types)]
6859pub type PFN_vkBindImageMemory = unsafe extern "system" fn(
6860 device: crate::vk1_0::Device,
6861 image: crate::vk1_0::Image,
6862 memory: crate::vk1_0::DeviceMemory,
6863 memory_offset: crate::vk1_0::DeviceSize,
6864) -> crate::vk1_0::Result;
6865#[allow(non_camel_case_types)]
6867pub type PFN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn(
6868 device: crate::vk1_0::Device,
6869 image: crate::vk1_0::Image,
6870 p_sparse_memory_requirement_count: *mut u32,
6871 p_sparse_memory_requirements: *mut crate::vk1_0::SparseImageMemoryRequirements,
6872) -> ();
6873#[allow(non_camel_case_types)]
6875pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe extern "system" fn(
6876 physical_device: crate::vk1_0::PhysicalDevice,
6877 format: crate::vk1_0::Format,
6878 _type: crate::vk1_0::ImageType,
6879 samples: crate::vk1_0::SampleCountFlagBits,
6880 usage: crate::vk1_0::ImageUsageFlags,
6881 tiling: crate::vk1_0::ImageTiling,
6882 p_property_count: *mut u32,
6883 p_properties: *mut crate::vk1_0::SparseImageFormatProperties,
6884) -> ();
6885#[allow(non_camel_case_types)]
6887pub type PFN_vkQueueBindSparse = unsafe extern "system" fn(
6888 queue: crate::vk1_0::Queue,
6889 bind_info_count: u32,
6890 p_bind_info: *const crate::vk1_0::BindSparseInfo,
6891 fence: crate::vk1_0::Fence,
6892) -> crate::vk1_0::Result;
6893#[allow(non_camel_case_types)]
6895pub type PFN_vkCreateFence = unsafe extern "system" fn(
6896 device: crate::vk1_0::Device,
6897 p_create_info: *const crate::vk1_0::FenceCreateInfo,
6898 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6899 p_fence: *mut crate::vk1_0::Fence,
6900) -> crate::vk1_0::Result;
6901#[allow(non_camel_case_types)]
6903pub type PFN_vkDestroyFence = unsafe extern "system" fn(
6904 device: crate::vk1_0::Device,
6905 fence: crate::vk1_0::Fence,
6906 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6907) -> ();
6908#[allow(non_camel_case_types)]
6910pub type PFN_vkResetFences = unsafe extern "system" fn(
6911 device: crate::vk1_0::Device,
6912 fence_count: u32,
6913 p_fences: *const crate::vk1_0::Fence,
6914) -> crate::vk1_0::Result;
6915#[allow(non_camel_case_types)]
6917pub type PFN_vkGetFenceStatus = unsafe extern "system" fn(
6918 device: crate::vk1_0::Device,
6919 fence: crate::vk1_0::Fence,
6920) -> crate::vk1_0::Result;
6921#[allow(non_camel_case_types)]
6923pub type PFN_vkWaitForFences = unsafe extern "system" fn(
6924 device: crate::vk1_0::Device,
6925 fence_count: u32,
6926 p_fences: *const crate::vk1_0::Fence,
6927 wait_all: crate::vk1_0::Bool32,
6928 timeout: u64,
6929) -> crate::vk1_0::Result;
6930#[allow(non_camel_case_types)]
6932pub type PFN_vkCreateSemaphore = unsafe extern "system" fn(
6933 device: crate::vk1_0::Device,
6934 p_create_info: *const crate::vk1_0::SemaphoreCreateInfo,
6935 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6936 p_semaphore: *mut crate::vk1_0::Semaphore,
6937) -> crate::vk1_0::Result;
6938#[allow(non_camel_case_types)]
6940pub type PFN_vkDestroySemaphore = unsafe extern "system" fn(
6941 device: crate::vk1_0::Device,
6942 semaphore: crate::vk1_0::Semaphore,
6943 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6944) -> ();
6945#[allow(non_camel_case_types)]
6947pub type PFN_vkCreateEvent = unsafe extern "system" fn(
6948 device: crate::vk1_0::Device,
6949 p_create_info: *const crate::vk1_0::EventCreateInfo,
6950 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6951 p_event: *mut crate::vk1_0::Event,
6952) -> crate::vk1_0::Result;
6953#[allow(non_camel_case_types)]
6955pub type PFN_vkDestroyEvent = unsafe extern "system" fn(
6956 device: crate::vk1_0::Device,
6957 event: crate::vk1_0::Event,
6958 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6959) -> ();
6960#[allow(non_camel_case_types)]
6962pub type PFN_vkGetEventStatus = unsafe extern "system" fn(
6963 device: crate::vk1_0::Device,
6964 event: crate::vk1_0::Event,
6965) -> crate::vk1_0::Result;
6966#[allow(non_camel_case_types)]
6968pub type PFN_vkSetEvent = unsafe extern "system" fn(
6969 device: crate::vk1_0::Device,
6970 event: crate::vk1_0::Event,
6971) -> crate::vk1_0::Result;
6972#[allow(non_camel_case_types)]
6974pub type PFN_vkResetEvent = unsafe extern "system" fn(
6975 device: crate::vk1_0::Device,
6976 event: crate::vk1_0::Event,
6977) -> crate::vk1_0::Result;
6978#[allow(non_camel_case_types)]
6980pub type PFN_vkCreateQueryPool = unsafe extern "system" fn(
6981 device: crate::vk1_0::Device,
6982 p_create_info: *const crate::vk1_0::QueryPoolCreateInfo,
6983 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6984 p_query_pool: *mut crate::vk1_0::QueryPool,
6985) -> crate::vk1_0::Result;
6986#[allow(non_camel_case_types)]
6988pub type PFN_vkDestroyQueryPool = unsafe extern "system" fn(
6989 device: crate::vk1_0::Device,
6990 query_pool: crate::vk1_0::QueryPool,
6991 p_allocator: *const crate::vk1_0::AllocationCallbacks,
6992) -> ();
6993#[allow(non_camel_case_types)]
6995pub type PFN_vkGetQueryPoolResults = unsafe extern "system" fn(
6996 device: crate::vk1_0::Device,
6997 query_pool: crate::vk1_0::QueryPool,
6998 first_query: u32,
6999 query_count: u32,
7000 data_size: usize,
7001 p_data: *mut std::ffi::c_void,
7002 stride: crate::vk1_0::DeviceSize,
7003 flags: crate::vk1_0::QueryResultFlags,
7004) -> crate::vk1_0::Result;
7005#[allow(non_camel_case_types)]
7007pub type PFN_vkCreateBuffer = unsafe extern "system" fn(
7008 device: crate::vk1_0::Device,
7009 p_create_info: *const crate::vk1_0::BufferCreateInfo,
7010 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7011 p_buffer: *mut crate::vk1_0::Buffer,
7012) -> crate::vk1_0::Result;
7013#[allow(non_camel_case_types)]
7015pub type PFN_vkDestroyBuffer = unsafe extern "system" fn(
7016 device: crate::vk1_0::Device,
7017 buffer: crate::vk1_0::Buffer,
7018 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7019) -> ();
7020#[allow(non_camel_case_types)]
7022pub type PFN_vkCreateBufferView = unsafe extern "system" fn(
7023 device: crate::vk1_0::Device,
7024 p_create_info: *const crate::vk1_0::BufferViewCreateInfo,
7025 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7026 p_view: *mut crate::vk1_0::BufferView,
7027) -> crate::vk1_0::Result;
7028#[allow(non_camel_case_types)]
7030pub type PFN_vkDestroyBufferView = unsafe extern "system" fn(
7031 device: crate::vk1_0::Device,
7032 buffer_view: crate::vk1_0::BufferView,
7033 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7034) -> ();
7035#[allow(non_camel_case_types)]
7037pub type PFN_vkCreateImage = unsafe extern "system" fn(
7038 device: crate::vk1_0::Device,
7039 p_create_info: *const crate::vk1_0::ImageCreateInfo,
7040 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7041 p_image: *mut crate::vk1_0::Image,
7042) -> crate::vk1_0::Result;
7043#[allow(non_camel_case_types)]
7045pub type PFN_vkDestroyImage = unsafe extern "system" fn(
7046 device: crate::vk1_0::Device,
7047 image: crate::vk1_0::Image,
7048 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7049) -> ();
7050#[allow(non_camel_case_types)]
7052pub type PFN_vkGetImageSubresourceLayout = unsafe extern "system" fn(
7053 device: crate::vk1_0::Device,
7054 image: crate::vk1_0::Image,
7055 p_subresource: *const crate::vk1_0::ImageSubresource,
7056 p_layout: *mut crate::vk1_0::SubresourceLayout,
7057) -> ();
7058#[allow(non_camel_case_types)]
7060pub type PFN_vkCreateImageView = unsafe extern "system" fn(
7061 device: crate::vk1_0::Device,
7062 p_create_info: *const crate::vk1_0::ImageViewCreateInfo,
7063 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7064 p_view: *mut crate::vk1_0::ImageView,
7065) -> crate::vk1_0::Result;
7066#[allow(non_camel_case_types)]
7068pub type PFN_vkDestroyImageView = unsafe extern "system" fn(
7069 device: crate::vk1_0::Device,
7070 image_view: crate::vk1_0::ImageView,
7071 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7072) -> ();
7073#[allow(non_camel_case_types)]
7075pub type PFN_vkCreateShaderModule = unsafe extern "system" fn(
7076 device: crate::vk1_0::Device,
7077 p_create_info: *const crate::vk1_0::ShaderModuleCreateInfo,
7078 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7079 p_shader_module: *mut crate::vk1_0::ShaderModule,
7080) -> crate::vk1_0::Result;
7081#[allow(non_camel_case_types)]
7083pub type PFN_vkDestroyShaderModule = unsafe extern "system" fn(
7084 device: crate::vk1_0::Device,
7085 shader_module: crate::vk1_0::ShaderModule,
7086 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7087) -> ();
7088#[allow(non_camel_case_types)]
7090pub type PFN_vkCreatePipelineCache = unsafe extern "system" fn(
7091 device: crate::vk1_0::Device,
7092 p_create_info: *const crate::vk1_0::PipelineCacheCreateInfo,
7093 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7094 p_pipeline_cache: *mut crate::vk1_0::PipelineCache,
7095) -> crate::vk1_0::Result;
7096#[allow(non_camel_case_types)]
7098pub type PFN_vkDestroyPipelineCache = unsafe extern "system" fn(
7099 device: crate::vk1_0::Device,
7100 pipeline_cache: crate::vk1_0::PipelineCache,
7101 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7102) -> ();
7103#[allow(non_camel_case_types)]
7105pub type PFN_vkGetPipelineCacheData = unsafe extern "system" fn(
7106 device: crate::vk1_0::Device,
7107 pipeline_cache: crate::vk1_0::PipelineCache,
7108 p_data_size: *mut usize,
7109 p_data: *mut std::ffi::c_void,
7110) -> crate::vk1_0::Result;
7111#[allow(non_camel_case_types)]
7113pub type PFN_vkMergePipelineCaches = unsafe extern "system" fn(
7114 device: crate::vk1_0::Device,
7115 dst_cache: crate::vk1_0::PipelineCache,
7116 src_cache_count: u32,
7117 p_src_caches: *const crate::vk1_0::PipelineCache,
7118) -> crate::vk1_0::Result;
7119#[allow(non_camel_case_types)]
7121pub type PFN_vkCreateGraphicsPipelines = unsafe extern "system" fn(
7122 device: crate::vk1_0::Device,
7123 pipeline_cache: crate::vk1_0::PipelineCache,
7124 create_info_count: u32,
7125 p_create_infos: *const crate::vk1_0::GraphicsPipelineCreateInfo,
7126 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7127 p_pipelines: *mut crate::vk1_0::Pipeline,
7128) -> crate::vk1_0::Result;
7129#[allow(non_camel_case_types)]
7131pub type PFN_vkCreateComputePipelines = unsafe extern "system" fn(
7132 device: crate::vk1_0::Device,
7133 pipeline_cache: crate::vk1_0::PipelineCache,
7134 create_info_count: u32,
7135 p_create_infos: *const crate::vk1_0::ComputePipelineCreateInfo,
7136 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7137 p_pipelines: *mut crate::vk1_0::Pipeline,
7138) -> crate::vk1_0::Result;
7139#[allow(non_camel_case_types)]
7141pub type PFN_vkDestroyPipeline = unsafe extern "system" fn(
7142 device: crate::vk1_0::Device,
7143 pipeline: crate::vk1_0::Pipeline,
7144 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7145) -> ();
7146#[allow(non_camel_case_types)]
7148pub type PFN_vkCreatePipelineLayout = unsafe extern "system" fn(
7149 device: crate::vk1_0::Device,
7150 p_create_info: *const crate::vk1_0::PipelineLayoutCreateInfo,
7151 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7152 p_pipeline_layout: *mut crate::vk1_0::PipelineLayout,
7153) -> crate::vk1_0::Result;
7154#[allow(non_camel_case_types)]
7156pub type PFN_vkDestroyPipelineLayout = unsafe extern "system" fn(
7157 device: crate::vk1_0::Device,
7158 pipeline_layout: crate::vk1_0::PipelineLayout,
7159 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7160) -> ();
7161#[allow(non_camel_case_types)]
7163pub type PFN_vkCreateSampler = unsafe extern "system" fn(
7164 device: crate::vk1_0::Device,
7165 p_create_info: *const crate::vk1_0::SamplerCreateInfo,
7166 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7167 p_sampler: *mut crate::vk1_0::Sampler,
7168) -> crate::vk1_0::Result;
7169#[allow(non_camel_case_types)]
7171pub type PFN_vkDestroySampler = unsafe extern "system" fn(
7172 device: crate::vk1_0::Device,
7173 sampler: crate::vk1_0::Sampler,
7174 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7175) -> ();
7176#[allow(non_camel_case_types)]
7178pub type PFN_vkCreateDescriptorSetLayout = unsafe extern "system" fn(
7179 device: crate::vk1_0::Device,
7180 p_create_info: *const crate::vk1_0::DescriptorSetLayoutCreateInfo,
7181 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7182 p_set_layout: *mut crate::vk1_0::DescriptorSetLayout,
7183) -> crate::vk1_0::Result;
7184#[allow(non_camel_case_types)]
7186pub type PFN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn(
7187 device: crate::vk1_0::Device,
7188 descriptor_set_layout: crate::vk1_0::DescriptorSetLayout,
7189 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7190) -> ();
7191#[allow(non_camel_case_types)]
7193pub type PFN_vkCreateDescriptorPool = unsafe extern "system" fn(
7194 device: crate::vk1_0::Device,
7195 p_create_info: *const crate::vk1_0::DescriptorPoolCreateInfo,
7196 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7197 p_descriptor_pool: *mut crate::vk1_0::DescriptorPool,
7198) -> crate::vk1_0::Result;
7199#[allow(non_camel_case_types)]
7201pub type PFN_vkDestroyDescriptorPool = unsafe extern "system" fn(
7202 device: crate::vk1_0::Device,
7203 descriptor_pool: crate::vk1_0::DescriptorPool,
7204 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7205) -> ();
7206#[allow(non_camel_case_types)]
7208pub type PFN_vkResetDescriptorPool = unsafe extern "system" fn(
7209 device: crate::vk1_0::Device,
7210 descriptor_pool: crate::vk1_0::DescriptorPool,
7211 flags: crate::vk1_0::DescriptorPoolResetFlags,
7212) -> crate::vk1_0::Result;
7213#[allow(non_camel_case_types)]
7215pub type PFN_vkAllocateDescriptorSets = unsafe extern "system" fn(
7216 device: crate::vk1_0::Device,
7217 p_allocate_info: *const crate::vk1_0::DescriptorSetAllocateInfo,
7218 p_descriptor_sets: *mut crate::vk1_0::DescriptorSet,
7219) -> crate::vk1_0::Result;
7220#[allow(non_camel_case_types)]
7222pub type PFN_vkFreeDescriptorSets = unsafe extern "system" fn(
7223 device: crate::vk1_0::Device,
7224 descriptor_pool: crate::vk1_0::DescriptorPool,
7225 descriptor_set_count: u32,
7226 p_descriptor_sets: *const crate::vk1_0::DescriptorSet,
7227) -> crate::vk1_0::Result;
7228#[allow(non_camel_case_types)]
7230pub type PFN_vkUpdateDescriptorSets = unsafe extern "system" fn(
7231 device: crate::vk1_0::Device,
7232 descriptor_write_count: u32,
7233 p_descriptor_writes: *const crate::vk1_0::WriteDescriptorSet,
7234 descriptor_copy_count: u32,
7235 p_descriptor_copies: *const crate::vk1_0::CopyDescriptorSet,
7236) -> ();
7237#[allow(non_camel_case_types)]
7239pub type PFN_vkCreateFramebuffer = unsafe extern "system" fn(
7240 device: crate::vk1_0::Device,
7241 p_create_info: *const crate::vk1_0::FramebufferCreateInfo,
7242 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7243 p_framebuffer: *mut crate::vk1_0::Framebuffer,
7244) -> crate::vk1_0::Result;
7245#[allow(non_camel_case_types)]
7247pub type PFN_vkDestroyFramebuffer = unsafe extern "system" fn(
7248 device: crate::vk1_0::Device,
7249 framebuffer: crate::vk1_0::Framebuffer,
7250 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7251) -> ();
7252#[allow(non_camel_case_types)]
7254pub type PFN_vkCreateRenderPass = unsafe extern "system" fn(
7255 device: crate::vk1_0::Device,
7256 p_create_info: *const crate::vk1_0::RenderPassCreateInfo,
7257 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7258 p_render_pass: *mut crate::vk1_0::RenderPass,
7259) -> crate::vk1_0::Result;
7260#[allow(non_camel_case_types)]
7262pub type PFN_vkDestroyRenderPass = unsafe extern "system" fn(
7263 device: crate::vk1_0::Device,
7264 render_pass: crate::vk1_0::RenderPass,
7265 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7266) -> ();
7267#[allow(non_camel_case_types)]
7269pub type PFN_vkGetRenderAreaGranularity = unsafe extern "system" fn(
7270 device: crate::vk1_0::Device,
7271 render_pass: crate::vk1_0::RenderPass,
7272 p_granularity: *mut crate::vk1_0::Extent2D,
7273) -> ();
7274#[allow(non_camel_case_types)]
7276pub type PFN_vkCreateCommandPool = unsafe extern "system" fn(
7277 device: crate::vk1_0::Device,
7278 p_create_info: *const crate::vk1_0::CommandPoolCreateInfo,
7279 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7280 p_command_pool: *mut crate::vk1_0::CommandPool,
7281) -> crate::vk1_0::Result;
7282#[allow(non_camel_case_types)]
7284pub type PFN_vkDestroyCommandPool = unsafe extern "system" fn(
7285 device: crate::vk1_0::Device,
7286 command_pool: crate::vk1_0::CommandPool,
7287 p_allocator: *const crate::vk1_0::AllocationCallbacks,
7288) -> ();
7289#[allow(non_camel_case_types)]
7291pub type PFN_vkResetCommandPool = unsafe extern "system" fn(
7292 device: crate::vk1_0::Device,
7293 command_pool: crate::vk1_0::CommandPool,
7294 flags: crate::vk1_0::CommandPoolResetFlags,
7295) -> crate::vk1_0::Result;
7296#[allow(non_camel_case_types)]
7298pub type PFN_vkAllocateCommandBuffers = unsafe extern "system" fn(
7299 device: crate::vk1_0::Device,
7300 p_allocate_info: *const crate::vk1_0::CommandBufferAllocateInfo,
7301 p_command_buffers: *mut crate::vk1_0::CommandBuffer,
7302) -> crate::vk1_0::Result;
7303#[allow(non_camel_case_types)]
7305pub type PFN_vkFreeCommandBuffers = unsafe extern "system" fn(
7306 device: crate::vk1_0::Device,
7307 command_pool: crate::vk1_0::CommandPool,
7308 command_buffer_count: u32,
7309 p_command_buffers: *const crate::vk1_0::CommandBuffer,
7310) -> ();
7311#[allow(non_camel_case_types)]
7313pub type PFN_vkBeginCommandBuffer = unsafe extern "system" fn(
7314 command_buffer: crate::vk1_0::CommandBuffer,
7315 p_begin_info: *const crate::vk1_0::CommandBufferBeginInfo,
7316) -> crate::vk1_0::Result;
7317#[allow(non_camel_case_types)]
7319pub type PFN_vkEndCommandBuffer = unsafe extern "system" fn(
7320 command_buffer: crate::vk1_0::CommandBuffer,
7321) -> crate::vk1_0::Result;
7322#[allow(non_camel_case_types)]
7324pub type PFN_vkResetCommandBuffer = unsafe extern "system" fn(
7325 command_buffer: crate::vk1_0::CommandBuffer,
7326 flags: crate::vk1_0::CommandBufferResetFlags,
7327) -> crate::vk1_0::Result;
7328#[allow(non_camel_case_types)]
7330pub type PFN_vkCmdBindPipeline = unsafe extern "system" fn(
7331 command_buffer: crate::vk1_0::CommandBuffer,
7332 pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
7333 pipeline: crate::vk1_0::Pipeline,
7334) -> ();
7335#[allow(non_camel_case_types)]
7337pub type PFN_vkCmdSetViewport = unsafe extern "system" fn(
7338 command_buffer: crate::vk1_0::CommandBuffer,
7339 first_viewport: u32,
7340 viewport_count: u32,
7341 p_viewports: *const crate::vk1_0::Viewport,
7342) -> ();
7343#[allow(non_camel_case_types)]
7345pub type PFN_vkCmdSetScissor = unsafe extern "system" fn(
7346 command_buffer: crate::vk1_0::CommandBuffer,
7347 first_scissor: u32,
7348 scissor_count: u32,
7349 p_scissors: *const crate::vk1_0::Rect2D,
7350) -> ();
7351#[allow(non_camel_case_types)]
7353pub type PFN_vkCmdSetLineWidth = unsafe extern "system" fn(
7354 command_buffer: crate::vk1_0::CommandBuffer,
7355 line_width: std::os::raw::c_float,
7356) -> ();
7357#[allow(non_camel_case_types)]
7359pub type PFN_vkCmdSetDepthBias = unsafe extern "system" fn(
7360 command_buffer: crate::vk1_0::CommandBuffer,
7361 depth_bias_constant_factor: std::os::raw::c_float,
7362 depth_bias_clamp: std::os::raw::c_float,
7363 depth_bias_slope_factor: std::os::raw::c_float,
7364) -> ();
7365#[allow(non_camel_case_types)]
7367pub type PFN_vkCmdSetBlendConstants = unsafe extern "system" fn(
7368 command_buffer: crate::vk1_0::CommandBuffer,
7369 blend_constants: [std::os::raw::c_float; 4],
7370) -> ();
7371#[allow(non_camel_case_types)]
7373pub type PFN_vkCmdSetDepthBounds = unsafe extern "system" fn(
7374 command_buffer: crate::vk1_0::CommandBuffer,
7375 min_depth_bounds: std::os::raw::c_float,
7376 max_depth_bounds: std::os::raw::c_float,
7377) -> ();
7378#[allow(non_camel_case_types)]
7380pub type PFN_vkCmdSetStencilCompareMask = unsafe extern "system" fn(
7381 command_buffer: crate::vk1_0::CommandBuffer,
7382 face_mask: crate::vk1_0::StencilFaceFlags,
7383 compare_mask: u32,
7384) -> ();
7385#[allow(non_camel_case_types)]
7387pub type PFN_vkCmdSetStencilWriteMask = unsafe extern "system" fn(
7388 command_buffer: crate::vk1_0::CommandBuffer,
7389 face_mask: crate::vk1_0::StencilFaceFlags,
7390 write_mask: u32,
7391) -> ();
7392#[allow(non_camel_case_types)]
7394pub type PFN_vkCmdSetStencilReference = unsafe extern "system" fn(
7395 command_buffer: crate::vk1_0::CommandBuffer,
7396 face_mask: crate::vk1_0::StencilFaceFlags,
7397 reference: u32,
7398) -> ();
7399#[allow(non_camel_case_types)]
7401pub type PFN_vkCmdBindDescriptorSets = unsafe extern "system" fn(
7402 command_buffer: crate::vk1_0::CommandBuffer,
7403 pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
7404 layout: crate::vk1_0::PipelineLayout,
7405 first_set: u32,
7406 descriptor_set_count: u32,
7407 p_descriptor_sets: *const crate::vk1_0::DescriptorSet,
7408 dynamic_offset_count: u32,
7409 p_dynamic_offsets: *const u32,
7410) -> ();
7411#[allow(non_camel_case_types)]
7413pub type PFN_vkCmdBindIndexBuffer = unsafe extern "system" fn(
7414 command_buffer: crate::vk1_0::CommandBuffer,
7415 buffer: crate::vk1_0::Buffer,
7416 offset: crate::vk1_0::DeviceSize,
7417 index_type: crate::vk1_0::IndexType,
7418) -> ();
7419#[allow(non_camel_case_types)]
7421pub type PFN_vkCmdBindVertexBuffers = unsafe extern "system" fn(
7422 command_buffer: crate::vk1_0::CommandBuffer,
7423 first_binding: u32,
7424 binding_count: u32,
7425 p_buffers: *const crate::vk1_0::Buffer,
7426 p_offsets: *const crate::vk1_0::DeviceSize,
7427) -> ();
7428#[allow(non_camel_case_types)]
7430pub type PFN_vkCmdDraw = unsafe extern "system" fn(
7431 command_buffer: crate::vk1_0::CommandBuffer,
7432 vertex_count: u32,
7433 instance_count: u32,
7434 first_vertex: u32,
7435 first_instance: u32,
7436) -> ();
7437#[allow(non_camel_case_types)]
7439pub type PFN_vkCmdDrawIndexed = unsafe extern "system" fn(
7440 command_buffer: crate::vk1_0::CommandBuffer,
7441 index_count: u32,
7442 instance_count: u32,
7443 first_index: u32,
7444 vertex_offset: i32,
7445 first_instance: u32,
7446) -> ();
7447#[allow(non_camel_case_types)]
7449pub type PFN_vkCmdDrawIndirect = unsafe extern "system" fn(
7450 command_buffer: crate::vk1_0::CommandBuffer,
7451 buffer: crate::vk1_0::Buffer,
7452 offset: crate::vk1_0::DeviceSize,
7453 draw_count: u32,
7454 stride: u32,
7455) -> ();
7456#[allow(non_camel_case_types)]
7458pub type PFN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn(
7459 command_buffer: crate::vk1_0::CommandBuffer,
7460 buffer: crate::vk1_0::Buffer,
7461 offset: crate::vk1_0::DeviceSize,
7462 draw_count: u32,
7463 stride: u32,
7464) -> ();
7465#[allow(non_camel_case_types)]
7467pub type PFN_vkCmdDispatch = unsafe extern "system" fn(
7468 command_buffer: crate::vk1_0::CommandBuffer,
7469 group_count_x: u32,
7470 group_count_y: u32,
7471 group_count_z: u32,
7472) -> ();
7473#[allow(non_camel_case_types)]
7475pub type PFN_vkCmdDispatchIndirect = unsafe extern "system" fn(
7476 command_buffer: crate::vk1_0::CommandBuffer,
7477 buffer: crate::vk1_0::Buffer,
7478 offset: crate::vk1_0::DeviceSize,
7479) -> ();
7480#[allow(non_camel_case_types)]
7482pub type PFN_vkCmdCopyBuffer = unsafe extern "system" fn(
7483 command_buffer: crate::vk1_0::CommandBuffer,
7484 src_buffer: crate::vk1_0::Buffer,
7485 dst_buffer: crate::vk1_0::Buffer,
7486 region_count: u32,
7487 p_regions: *const crate::vk1_0::BufferCopy,
7488) -> ();
7489#[allow(non_camel_case_types)]
7491pub type PFN_vkCmdCopyImage = unsafe extern "system" fn(
7492 command_buffer: crate::vk1_0::CommandBuffer,
7493 src_image: crate::vk1_0::Image,
7494 src_image_layout: crate::vk1_0::ImageLayout,
7495 dst_image: crate::vk1_0::Image,
7496 dst_image_layout: crate::vk1_0::ImageLayout,
7497 region_count: u32,
7498 p_regions: *const crate::vk1_0::ImageCopy,
7499) -> ();
7500#[allow(non_camel_case_types)]
7502pub type PFN_vkCmdBlitImage = unsafe extern "system" fn(
7503 command_buffer: crate::vk1_0::CommandBuffer,
7504 src_image: crate::vk1_0::Image,
7505 src_image_layout: crate::vk1_0::ImageLayout,
7506 dst_image: crate::vk1_0::Image,
7507 dst_image_layout: crate::vk1_0::ImageLayout,
7508 region_count: u32,
7509 p_regions: *const crate::vk1_0::ImageBlit,
7510 filter: crate::vk1_0::Filter,
7511) -> ();
7512#[allow(non_camel_case_types)]
7514pub type PFN_vkCmdCopyBufferToImage = unsafe extern "system" fn(
7515 command_buffer: crate::vk1_0::CommandBuffer,
7516 src_buffer: crate::vk1_0::Buffer,
7517 dst_image: crate::vk1_0::Image,
7518 dst_image_layout: crate::vk1_0::ImageLayout,
7519 region_count: u32,
7520 p_regions: *const crate::vk1_0::BufferImageCopy,
7521) -> ();
7522#[allow(non_camel_case_types)]
7524pub type PFN_vkCmdCopyImageToBuffer = unsafe extern "system" fn(
7525 command_buffer: crate::vk1_0::CommandBuffer,
7526 src_image: crate::vk1_0::Image,
7527 src_image_layout: crate::vk1_0::ImageLayout,
7528 dst_buffer: crate::vk1_0::Buffer,
7529 region_count: u32,
7530 p_regions: *const crate::vk1_0::BufferImageCopy,
7531) -> ();
7532#[allow(non_camel_case_types)]
7534pub type PFN_vkCmdUpdateBuffer = unsafe extern "system" fn(
7535 command_buffer: crate::vk1_0::CommandBuffer,
7536 dst_buffer: crate::vk1_0::Buffer,
7537 dst_offset: crate::vk1_0::DeviceSize,
7538 data_size: crate::vk1_0::DeviceSize,
7539 p_data: *const std::ffi::c_void,
7540) -> ();
7541#[allow(non_camel_case_types)]
7543pub type PFN_vkCmdFillBuffer = unsafe extern "system" fn(
7544 command_buffer: crate::vk1_0::CommandBuffer,
7545 dst_buffer: crate::vk1_0::Buffer,
7546 dst_offset: crate::vk1_0::DeviceSize,
7547 size: crate::vk1_0::DeviceSize,
7548 data: u32,
7549) -> ();
7550#[allow(non_camel_case_types)]
7552pub type PFN_vkCmdClearColorImage = unsafe extern "system" fn(
7553 command_buffer: crate::vk1_0::CommandBuffer,
7554 image: crate::vk1_0::Image,
7555 image_layout: crate::vk1_0::ImageLayout,
7556 p_color: *const crate::vk1_0::ClearColorValue,
7557 range_count: u32,
7558 p_ranges: *const crate::vk1_0::ImageSubresourceRange,
7559) -> ();
7560#[allow(non_camel_case_types)]
7562pub type PFN_vkCmdClearDepthStencilImage = unsafe extern "system" fn(
7563 command_buffer: crate::vk1_0::CommandBuffer,
7564 image: crate::vk1_0::Image,
7565 image_layout: crate::vk1_0::ImageLayout,
7566 p_depth_stencil: *const crate::vk1_0::ClearDepthStencilValue,
7567 range_count: u32,
7568 p_ranges: *const crate::vk1_0::ImageSubresourceRange,
7569) -> ();
7570#[allow(non_camel_case_types)]
7572pub type PFN_vkCmdClearAttachments = unsafe extern "system" fn(
7573 command_buffer: crate::vk1_0::CommandBuffer,
7574 attachment_count: u32,
7575 p_attachments: *const crate::vk1_0::ClearAttachment,
7576 rect_count: u32,
7577 p_rects: *const crate::vk1_0::ClearRect,
7578) -> ();
7579#[allow(non_camel_case_types)]
7581pub type PFN_vkCmdResolveImage = unsafe extern "system" fn(
7582 command_buffer: crate::vk1_0::CommandBuffer,
7583 src_image: crate::vk1_0::Image,
7584 src_image_layout: crate::vk1_0::ImageLayout,
7585 dst_image: crate::vk1_0::Image,
7586 dst_image_layout: crate::vk1_0::ImageLayout,
7587 region_count: u32,
7588 p_regions: *const crate::vk1_0::ImageResolve,
7589) -> ();
7590#[allow(non_camel_case_types)]
7592pub type PFN_vkCmdSetEvent = unsafe extern "system" fn(
7593 command_buffer: crate::vk1_0::CommandBuffer,
7594 event: crate::vk1_0::Event,
7595 stage_mask: crate::vk1_0::PipelineStageFlags,
7596) -> ();
7597#[allow(non_camel_case_types)]
7599pub type PFN_vkCmdResetEvent = unsafe extern "system" fn(
7600 command_buffer: crate::vk1_0::CommandBuffer,
7601 event: crate::vk1_0::Event,
7602 stage_mask: crate::vk1_0::PipelineStageFlags,
7603) -> ();
7604#[allow(non_camel_case_types)]
7606pub type PFN_vkCmdWaitEvents = unsafe extern "system" fn(
7607 command_buffer: crate::vk1_0::CommandBuffer,
7608 event_count: u32,
7609 p_events: *const crate::vk1_0::Event,
7610 src_stage_mask: crate::vk1_0::PipelineStageFlags,
7611 dst_stage_mask: crate::vk1_0::PipelineStageFlags,
7612 memory_barrier_count: u32,
7613 p_memory_barriers: *const crate::vk1_0::MemoryBarrier,
7614 buffer_memory_barrier_count: u32,
7615 p_buffer_memory_barriers: *const crate::vk1_0::BufferMemoryBarrier,
7616 image_memory_barrier_count: u32,
7617 p_image_memory_barriers: *const crate::vk1_0::ImageMemoryBarrier,
7618) -> ();
7619#[allow(non_camel_case_types)]
7621pub type PFN_vkCmdPipelineBarrier = unsafe extern "system" fn(
7622 command_buffer: crate::vk1_0::CommandBuffer,
7623 src_stage_mask: crate::vk1_0::PipelineStageFlags,
7624 dst_stage_mask: crate::vk1_0::PipelineStageFlags,
7625 dependency_flags: crate::vk1_0::DependencyFlags,
7626 memory_barrier_count: u32,
7627 p_memory_barriers: *const crate::vk1_0::MemoryBarrier,
7628 buffer_memory_barrier_count: u32,
7629 p_buffer_memory_barriers: *const crate::vk1_0::BufferMemoryBarrier,
7630 image_memory_barrier_count: u32,
7631 p_image_memory_barriers: *const crate::vk1_0::ImageMemoryBarrier,
7632) -> ();
7633#[allow(non_camel_case_types)]
7635pub type PFN_vkCmdBeginQuery = unsafe extern "system" fn(
7636 command_buffer: crate::vk1_0::CommandBuffer,
7637 query_pool: crate::vk1_0::QueryPool,
7638 query: u32,
7639 flags: crate::vk1_0::QueryControlFlags,
7640) -> ();
7641#[allow(non_camel_case_types)]
7643pub type PFN_vkCmdEndQuery = unsafe extern "system" fn(
7644 command_buffer: crate::vk1_0::CommandBuffer,
7645 query_pool: crate::vk1_0::QueryPool,
7646 query: u32,
7647) -> ();
7648#[allow(non_camel_case_types)]
7650pub type PFN_vkCmdResetQueryPool = unsafe extern "system" fn(
7651 command_buffer: crate::vk1_0::CommandBuffer,
7652 query_pool: crate::vk1_0::QueryPool,
7653 first_query: u32,
7654 query_count: u32,
7655) -> ();
7656#[allow(non_camel_case_types)]
7658pub type PFN_vkCmdWriteTimestamp = unsafe extern "system" fn(
7659 command_buffer: crate::vk1_0::CommandBuffer,
7660 pipeline_stage: crate::vk1_0::PipelineStageFlagBits,
7661 query_pool: crate::vk1_0::QueryPool,
7662 query: u32,
7663) -> ();
7664#[allow(non_camel_case_types)]
7666pub type PFN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn(
7667 command_buffer: crate::vk1_0::CommandBuffer,
7668 query_pool: crate::vk1_0::QueryPool,
7669 first_query: u32,
7670 query_count: u32,
7671 dst_buffer: crate::vk1_0::Buffer,
7672 dst_offset: crate::vk1_0::DeviceSize,
7673 stride: crate::vk1_0::DeviceSize,
7674 flags: crate::vk1_0::QueryResultFlags,
7675) -> ();
7676#[allow(non_camel_case_types)]
7678pub type PFN_vkCmdPushConstants = unsafe extern "system" fn(
7679 command_buffer: crate::vk1_0::CommandBuffer,
7680 layout: crate::vk1_0::PipelineLayout,
7681 stage_flags: crate::vk1_0::ShaderStageFlags,
7682 offset: u32,
7683 size: u32,
7684 p_values: *const std::ffi::c_void,
7685) -> ();
7686#[allow(non_camel_case_types)]
7688pub type PFN_vkCmdBeginRenderPass = unsafe extern "system" fn(
7689 command_buffer: crate::vk1_0::CommandBuffer,
7690 p_render_pass_begin: *const crate::vk1_0::RenderPassBeginInfo,
7691 contents: crate::vk1_0::SubpassContents,
7692) -> ();
7693#[allow(non_camel_case_types)]
7695pub type PFN_vkCmdNextSubpass = unsafe extern "system" fn(
7696 command_buffer: crate::vk1_0::CommandBuffer,
7697 contents: crate::vk1_0::SubpassContents,
7698) -> ();
7699#[allow(non_camel_case_types)]
7701pub type PFN_vkCmdEndRenderPass = unsafe extern "system" fn(
7702 command_buffer: crate::vk1_0::CommandBuffer,
7703) -> ();
7704#[allow(non_camel_case_types)]
7706pub type PFN_vkCmdExecuteCommands = unsafe extern "system" fn(
7707 command_buffer: crate::vk1_0::CommandBuffer,
7708 command_buffer_count: u32,
7709 p_command_buffers: *const crate::vk1_0::CommandBuffer,
7710) -> ();
7711#[allow(non_camel_case_types)]
7713pub type PFN_vkInternalAllocationNotification = unsafe extern "system" fn(
7714 p_user_data: *mut std::ffi::c_void,
7715 size: usize,
7716 allocation_type: crate::vk1_0::InternalAllocationType,
7717 allocation_scope: crate::vk1_0::SystemAllocationScope,
7718) -> ();
7719#[allow(non_camel_case_types)]
7721pub type PFN_vkInternalFreeNotification = unsafe extern "system" fn(
7722 p_user_data: *mut std::ffi::c_void,
7723 size: usize,
7724 allocation_type: crate::vk1_0::InternalAllocationType,
7725 allocation_scope: crate::vk1_0::SystemAllocationScope,
7726) -> ();
7727#[allow(non_camel_case_types)]
7729pub type PFN_vkReallocationFunction = unsafe extern "system" fn(
7730 p_user_data: *mut std::ffi::c_void,
7731 p_original: *mut std::ffi::c_void,
7732 size: usize,
7733 alignment: usize,
7734 allocation_scope: crate::vk1_0::SystemAllocationScope,
7735) -> *mut std::ffi::c_void;
7736#[allow(non_camel_case_types)]
7738pub type PFN_vkAllocationFunction = unsafe extern "system" fn(
7739 p_user_data: *mut std::ffi::c_void,
7740 size: usize,
7741 alignment: usize,
7742 allocation_scope: crate::vk1_0::SystemAllocationScope,
7743) -> *mut std::ffi::c_void;
7744#[allow(non_camel_case_types)]
7746pub type PFN_vkFreeFunction = unsafe extern "system" fn(
7747 p_user_data: *mut std::ffi::c_void,
7748 p_memory: *mut std::ffi::c_void,
7749) -> ();
7750#[allow(non_camel_case_types)]
7752pub type PFN_vkVoidFunction = unsafe extern "system" fn() -> ();
7753#[doc(alias = "VkBaseOutStructure")]
7755#[derive(Copy, Clone)]
7756#[repr(C)]
7757pub struct BaseOutStructure {
7758 pub s_type: crate::vk1_0::StructureType,
7759 pub p_next: *mut crate::vk1_0::BaseOutStructure,
7760}
7761impl Default for BaseOutStructure {
7762 fn default() -> Self {
7763 Self {
7764 s_type: Default::default(),
7765 p_next: std::ptr::null_mut(),
7766 }
7767 }
7768}
7769impl std::fmt::Debug for BaseOutStructure {
7770 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
7771 f.debug_struct("BaseOutStructure")
7772 .field("s_type", &self.s_type)
7773 .field("p_next", &self.p_next)
7774 .finish()
7775 }
7776}
7777impl BaseOutStructure {
7778 #[inline]
7779 pub fn into_builder<'a>(self) -> BaseOutStructureBuilder<'a> {
7780 BaseOutStructureBuilder(self, std::marker::PhantomData)
7781 }
7782}
7783#[derive(Copy, Clone)]
7784#[repr(transparent)]
7786pub struct BaseOutStructureBuilder<'a>(
7787 BaseOutStructure,
7788 std::marker::PhantomData<&'a ()>,
7789);
7790impl<'a> BaseOutStructureBuilder<'a> {
7791 #[inline]
7792 pub fn new() -> BaseOutStructureBuilder<'a> {
7793 BaseOutStructureBuilder(Default::default(), std::marker::PhantomData)
7794 }
7795 #[inline]
7796 #[must_use]
7797 pub fn next(mut self, next: &'a mut crate::vk1_0::BaseOutStructure) -> Self {
7798 self.0.p_next = next as _;
7799 self
7800 }
7801 #[inline]
7802 pub fn build_dangling(self) -> BaseOutStructure {
7805 self.0
7806 }
7807}
7808impl<'a> std::default::Default for BaseOutStructureBuilder<'a> {
7809 fn default() -> BaseOutStructureBuilder<'a> {
7810 Self::new()
7811 }
7812}
7813impl<'a> std::fmt::Debug for BaseOutStructureBuilder<'a> {
7814 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
7815 std::fmt::Debug::fmt(&self.0, f)
7816 }
7817}
7818impl<'a> std::ops::Deref for BaseOutStructureBuilder<'a> {
7819 type Target = BaseOutStructure;
7820 fn deref(&self) -> &Self::Target {
7821 &self.0
7822 }
7823}
7824impl<'a> std::ops::DerefMut for BaseOutStructureBuilder<'a> {
7825 fn deref_mut(&mut self) -> &mut Self::Target {
7826 &mut self.0
7827 }
7828}
7829#[doc(alias = "VkBaseInStructure")]
7831#[derive(Copy, Clone)]
7832#[repr(C)]
7833pub struct BaseInStructure {
7834 pub s_type: crate::vk1_0::StructureType,
7835 pub p_next: *const crate::vk1_0::BaseInStructure,
7836}
7837impl Default for BaseInStructure {
7838 fn default() -> Self {
7839 Self {
7840 s_type: Default::default(),
7841 p_next: std::ptr::null(),
7842 }
7843 }
7844}
7845impl std::fmt::Debug for BaseInStructure {
7846 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
7847 f.debug_struct("BaseInStructure")
7848 .field("s_type", &self.s_type)
7849 .field("p_next", &self.p_next)
7850 .finish()
7851 }
7852}
7853impl BaseInStructure {
7854 #[inline]
7855 pub fn into_builder<'a>(self) -> BaseInStructureBuilder<'a> {
7856 BaseInStructureBuilder(self, std::marker::PhantomData)
7857 }
7858}
7859#[derive(Copy, Clone)]
7860#[repr(transparent)]
7862pub struct BaseInStructureBuilder<'a>(BaseInStructure, std::marker::PhantomData<&'a ()>);
7863impl<'a> BaseInStructureBuilder<'a> {
7864 #[inline]
7865 pub fn new() -> BaseInStructureBuilder<'a> {
7866 BaseInStructureBuilder(Default::default(), std::marker::PhantomData)
7867 }
7868 #[inline]
7869 #[must_use]
7870 pub fn next(mut self, next: &'a crate::vk1_0::BaseInStructure) -> Self {
7871 self.0.p_next = next as _;
7872 self
7873 }
7874 #[inline]
7875 pub fn build_dangling(self) -> BaseInStructure {
7878 self.0
7879 }
7880}
7881impl<'a> std::default::Default for BaseInStructureBuilder<'a> {
7882 fn default() -> BaseInStructureBuilder<'a> {
7883 Self::new()
7884 }
7885}
7886impl<'a> std::fmt::Debug for BaseInStructureBuilder<'a> {
7887 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
7888 std::fmt::Debug::fmt(&self.0, f)
7889 }
7890}
7891impl<'a> std::ops::Deref for BaseInStructureBuilder<'a> {
7892 type Target = BaseInStructure;
7893 fn deref(&self) -> &Self::Target {
7894 &self.0
7895 }
7896}
7897impl<'a> std::ops::DerefMut for BaseInStructureBuilder<'a> {
7898 fn deref_mut(&mut self) -> &mut Self::Target {
7899 &mut self.0
7900 }
7901}
7902#[doc(alias = "VkOffset2D")]
7904#[derive(Copy, Clone, Hash, PartialEq, Eq)]
7905#[repr(C)]
7906pub struct Offset2D {
7907 pub x: i32,
7908 pub y: i32,
7909}
7910impl Default for Offset2D {
7911 fn default() -> Self {
7912 Self {
7913 x: Default::default(),
7914 y: Default::default(),
7915 }
7916 }
7917}
7918impl std::fmt::Debug for Offset2D {
7919 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
7920 f.debug_struct("Offset2D").field("x", &self.x).field("y", &self.y).finish()
7921 }
7922}
7923impl Offset2D {
7924 #[inline]
7925 pub fn into_builder<'a>(self) -> Offset2DBuilder<'a> {
7926 Offset2DBuilder(self, std::marker::PhantomData)
7927 }
7928}
7929#[derive(Copy, Clone)]
7930#[repr(transparent)]
7932pub struct Offset2DBuilder<'a>(Offset2D, std::marker::PhantomData<&'a ()>);
7933impl<'a> Offset2DBuilder<'a> {
7934 #[inline]
7935 pub fn new() -> Offset2DBuilder<'a> {
7936 Offset2DBuilder(Default::default(), std::marker::PhantomData)
7937 }
7938 #[inline]
7939 #[must_use]
7940 pub fn x(mut self, x: i32) -> Self {
7941 self.0.x = x as _;
7942 self
7943 }
7944 #[inline]
7945 #[must_use]
7946 pub fn y(mut self, y: i32) -> Self {
7947 self.0.y = y as _;
7948 self
7949 }
7950 #[inline]
7951 pub fn build(self) -> Offset2D {
7952 self.0
7953 }
7954}
7955impl<'a> std::default::Default for Offset2DBuilder<'a> {
7956 fn default() -> Offset2DBuilder<'a> {
7957 Self::new()
7958 }
7959}
7960impl<'a> std::fmt::Debug for Offset2DBuilder<'a> {
7961 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
7962 std::fmt::Debug::fmt(&self.0, f)
7963 }
7964}
7965impl<'a> std::ops::Deref for Offset2DBuilder<'a> {
7966 type Target = Offset2D;
7967 fn deref(&self) -> &Self::Target {
7968 &self.0
7969 }
7970}
7971impl<'a> std::ops::DerefMut for Offset2DBuilder<'a> {
7972 fn deref_mut(&mut self) -> &mut Self::Target {
7973 &mut self.0
7974 }
7975}
7976#[doc(alias = "VkOffset3D")]
7978#[derive(Copy, Clone, Hash, PartialEq, Eq)]
7979#[repr(C)]
7980pub struct Offset3D {
7981 pub x: i32,
7982 pub y: i32,
7983 pub z: i32,
7984}
7985impl Default for Offset3D {
7986 fn default() -> Self {
7987 Self {
7988 x: Default::default(),
7989 y: Default::default(),
7990 z: Default::default(),
7991 }
7992 }
7993}
7994impl std::fmt::Debug for Offset3D {
7995 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
7996 f.debug_struct("Offset3D")
7997 .field("x", &self.x)
7998 .field("y", &self.y)
7999 .field("z", &self.z)
8000 .finish()
8001 }
8002}
8003impl Offset3D {
8004 #[inline]
8005 pub fn into_builder<'a>(self) -> Offset3DBuilder<'a> {
8006 Offset3DBuilder(self, std::marker::PhantomData)
8007 }
8008}
8009#[derive(Copy, Clone)]
8010#[repr(transparent)]
8012pub struct Offset3DBuilder<'a>(Offset3D, std::marker::PhantomData<&'a ()>);
8013impl<'a> Offset3DBuilder<'a> {
8014 #[inline]
8015 pub fn new() -> Offset3DBuilder<'a> {
8016 Offset3DBuilder(Default::default(), std::marker::PhantomData)
8017 }
8018 #[inline]
8019 #[must_use]
8020 pub fn x(mut self, x: i32) -> Self {
8021 self.0.x = x as _;
8022 self
8023 }
8024 #[inline]
8025 #[must_use]
8026 pub fn y(mut self, y: i32) -> Self {
8027 self.0.y = y as _;
8028 self
8029 }
8030 #[inline]
8031 #[must_use]
8032 pub fn z(mut self, z: i32) -> Self {
8033 self.0.z = z as _;
8034 self
8035 }
8036 #[inline]
8037 pub fn build(self) -> Offset3D {
8038 self.0
8039 }
8040}
8041impl<'a> std::default::Default for Offset3DBuilder<'a> {
8042 fn default() -> Offset3DBuilder<'a> {
8043 Self::new()
8044 }
8045}
8046impl<'a> std::fmt::Debug for Offset3DBuilder<'a> {
8047 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8048 std::fmt::Debug::fmt(&self.0, f)
8049 }
8050}
8051impl<'a> std::ops::Deref for Offset3DBuilder<'a> {
8052 type Target = Offset3D;
8053 fn deref(&self) -> &Self::Target {
8054 &self.0
8055 }
8056}
8057impl<'a> std::ops::DerefMut for Offset3DBuilder<'a> {
8058 fn deref_mut(&mut self) -> &mut Self::Target {
8059 &mut self.0
8060 }
8061}
8062#[doc(alias = "VkExtent2D")]
8064#[derive(Copy, Clone, Hash, PartialEq, Eq)]
8065#[repr(C)]
8066pub struct Extent2D {
8067 pub width: u32,
8068 pub height: u32,
8069}
8070impl Default for Extent2D {
8071 fn default() -> Self {
8072 Self {
8073 width: Default::default(),
8074 height: Default::default(),
8075 }
8076 }
8077}
8078impl std::fmt::Debug for Extent2D {
8079 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8080 f.debug_struct("Extent2D")
8081 .field("width", &self.width)
8082 .field("height", &self.height)
8083 .finish()
8084 }
8085}
8086impl Extent2D {
8087 #[inline]
8088 pub fn into_builder<'a>(self) -> Extent2DBuilder<'a> {
8089 Extent2DBuilder(self, std::marker::PhantomData)
8090 }
8091}
8092#[derive(Copy, Clone)]
8093#[repr(transparent)]
8095pub struct Extent2DBuilder<'a>(Extent2D, std::marker::PhantomData<&'a ()>);
8096impl<'a> Extent2DBuilder<'a> {
8097 #[inline]
8098 pub fn new() -> Extent2DBuilder<'a> {
8099 Extent2DBuilder(Default::default(), std::marker::PhantomData)
8100 }
8101 #[inline]
8102 #[must_use]
8103 pub fn width(mut self, width: u32) -> Self {
8104 self.0.width = width as _;
8105 self
8106 }
8107 #[inline]
8108 #[must_use]
8109 pub fn height(mut self, height: u32) -> Self {
8110 self.0.height = height as _;
8111 self
8112 }
8113 #[inline]
8114 pub fn build(self) -> Extent2D {
8115 self.0
8116 }
8117}
8118impl<'a> std::default::Default for Extent2DBuilder<'a> {
8119 fn default() -> Extent2DBuilder<'a> {
8120 Self::new()
8121 }
8122}
8123impl<'a> std::fmt::Debug for Extent2DBuilder<'a> {
8124 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8125 std::fmt::Debug::fmt(&self.0, f)
8126 }
8127}
8128impl<'a> std::ops::Deref for Extent2DBuilder<'a> {
8129 type Target = Extent2D;
8130 fn deref(&self) -> &Self::Target {
8131 &self.0
8132 }
8133}
8134impl<'a> std::ops::DerefMut for Extent2DBuilder<'a> {
8135 fn deref_mut(&mut self) -> &mut Self::Target {
8136 &mut self.0
8137 }
8138}
8139#[doc(alias = "VkExtent3D")]
8141#[derive(Copy, Clone, Hash, PartialEq, Eq)]
8142#[repr(C)]
8143pub struct Extent3D {
8144 pub width: u32,
8145 pub height: u32,
8146 pub depth: u32,
8147}
8148impl Default for Extent3D {
8149 fn default() -> Self {
8150 Self {
8151 width: Default::default(),
8152 height: Default::default(),
8153 depth: Default::default(),
8154 }
8155 }
8156}
8157impl std::fmt::Debug for Extent3D {
8158 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8159 f.debug_struct("Extent3D")
8160 .field("width", &self.width)
8161 .field("height", &self.height)
8162 .field("depth", &self.depth)
8163 .finish()
8164 }
8165}
8166impl Extent3D {
8167 #[inline]
8168 pub fn into_builder<'a>(self) -> Extent3DBuilder<'a> {
8169 Extent3DBuilder(self, std::marker::PhantomData)
8170 }
8171}
8172#[derive(Copy, Clone)]
8173#[repr(transparent)]
8175pub struct Extent3DBuilder<'a>(Extent3D, std::marker::PhantomData<&'a ()>);
8176impl<'a> Extent3DBuilder<'a> {
8177 #[inline]
8178 pub fn new() -> Extent3DBuilder<'a> {
8179 Extent3DBuilder(Default::default(), std::marker::PhantomData)
8180 }
8181 #[inline]
8182 #[must_use]
8183 pub fn width(mut self, width: u32) -> Self {
8184 self.0.width = width as _;
8185 self
8186 }
8187 #[inline]
8188 #[must_use]
8189 pub fn height(mut self, height: u32) -> Self {
8190 self.0.height = height as _;
8191 self
8192 }
8193 #[inline]
8194 #[must_use]
8195 pub fn depth(mut self, depth: u32) -> Self {
8196 self.0.depth = depth as _;
8197 self
8198 }
8199 #[inline]
8200 pub fn build(self) -> Extent3D {
8201 self.0
8202 }
8203}
8204impl<'a> std::default::Default for Extent3DBuilder<'a> {
8205 fn default() -> Extent3DBuilder<'a> {
8206 Self::new()
8207 }
8208}
8209impl<'a> std::fmt::Debug for Extent3DBuilder<'a> {
8210 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8211 std::fmt::Debug::fmt(&self.0, f)
8212 }
8213}
8214impl<'a> std::ops::Deref for Extent3DBuilder<'a> {
8215 type Target = Extent3D;
8216 fn deref(&self) -> &Self::Target {
8217 &self.0
8218 }
8219}
8220impl<'a> std::ops::DerefMut for Extent3DBuilder<'a> {
8221 fn deref_mut(&mut self) -> &mut Self::Target {
8222 &mut self.0
8223 }
8224}
8225#[doc(alias = "VkViewport")]
8227#[derive(Copy, Clone)]
8228#[repr(C)]
8229pub struct Viewport {
8230 pub x: std::os::raw::c_float,
8231 pub y: std::os::raw::c_float,
8232 pub width: std::os::raw::c_float,
8233 pub height: std::os::raw::c_float,
8234 pub min_depth: std::os::raw::c_float,
8235 pub max_depth: std::os::raw::c_float,
8236}
8237impl Default for Viewport {
8238 fn default() -> Self {
8239 Self {
8240 x: Default::default(),
8241 y: Default::default(),
8242 width: Default::default(),
8243 height: Default::default(),
8244 min_depth: Default::default(),
8245 max_depth: Default::default(),
8246 }
8247 }
8248}
8249impl std::fmt::Debug for Viewport {
8250 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8251 f.debug_struct("Viewport")
8252 .field("x", &self.x)
8253 .field("y", &self.y)
8254 .field("width", &self.width)
8255 .field("height", &self.height)
8256 .field("min_depth", &self.min_depth)
8257 .field("max_depth", &self.max_depth)
8258 .finish()
8259 }
8260}
8261impl Viewport {
8262 #[inline]
8263 pub fn into_builder<'a>(self) -> ViewportBuilder<'a> {
8264 ViewportBuilder(self, std::marker::PhantomData)
8265 }
8266}
8267#[derive(Copy, Clone)]
8268#[repr(transparent)]
8270pub struct ViewportBuilder<'a>(Viewport, std::marker::PhantomData<&'a ()>);
8271impl<'a> ViewportBuilder<'a> {
8272 #[inline]
8273 pub fn new() -> ViewportBuilder<'a> {
8274 ViewportBuilder(Default::default(), std::marker::PhantomData)
8275 }
8276 #[inline]
8277 #[must_use]
8278 pub fn x(mut self, x: std::os::raw::c_float) -> Self {
8279 self.0.x = x as _;
8280 self
8281 }
8282 #[inline]
8283 #[must_use]
8284 pub fn y(mut self, y: std::os::raw::c_float) -> Self {
8285 self.0.y = y as _;
8286 self
8287 }
8288 #[inline]
8289 #[must_use]
8290 pub fn width(mut self, width: std::os::raw::c_float) -> Self {
8291 self.0.width = width as _;
8292 self
8293 }
8294 #[inline]
8295 #[must_use]
8296 pub fn height(mut self, height: std::os::raw::c_float) -> Self {
8297 self.0.height = height as _;
8298 self
8299 }
8300 #[inline]
8301 #[must_use]
8302 pub fn min_depth(mut self, min_depth: std::os::raw::c_float) -> Self {
8303 self.0.min_depth = min_depth as _;
8304 self
8305 }
8306 #[inline]
8307 #[must_use]
8308 pub fn max_depth(mut self, max_depth: std::os::raw::c_float) -> Self {
8309 self.0.max_depth = max_depth as _;
8310 self
8311 }
8312 #[inline]
8313 pub fn build(self) -> Viewport {
8314 self.0
8315 }
8316}
8317impl<'a> std::default::Default for ViewportBuilder<'a> {
8318 fn default() -> ViewportBuilder<'a> {
8319 Self::new()
8320 }
8321}
8322impl<'a> std::fmt::Debug for ViewportBuilder<'a> {
8323 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8324 std::fmt::Debug::fmt(&self.0, f)
8325 }
8326}
8327impl<'a> std::ops::Deref for ViewportBuilder<'a> {
8328 type Target = Viewport;
8329 fn deref(&self) -> &Self::Target {
8330 &self.0
8331 }
8332}
8333impl<'a> std::ops::DerefMut for ViewportBuilder<'a> {
8334 fn deref_mut(&mut self) -> &mut Self::Target {
8335 &mut self.0
8336 }
8337}
8338#[doc(alias = "VkRect2D")]
8340#[derive(Copy, Clone, Hash, PartialEq, Eq)]
8341#[repr(C)]
8342pub struct Rect2D {
8343 pub offset: crate::vk1_0::Offset2D,
8344 pub extent: crate::vk1_0::Extent2D,
8345}
8346impl Default for Rect2D {
8347 fn default() -> Self {
8348 Self {
8349 offset: Default::default(),
8350 extent: Default::default(),
8351 }
8352 }
8353}
8354impl std::fmt::Debug for Rect2D {
8355 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8356 f.debug_struct("Rect2D")
8357 .field("offset", &self.offset)
8358 .field("extent", &self.extent)
8359 .finish()
8360 }
8361}
8362impl Rect2D {
8363 #[inline]
8364 pub fn into_builder<'a>(self) -> Rect2DBuilder<'a> {
8365 Rect2DBuilder(self, std::marker::PhantomData)
8366 }
8367}
8368#[derive(Copy, Clone)]
8369#[repr(transparent)]
8371pub struct Rect2DBuilder<'a>(Rect2D, std::marker::PhantomData<&'a ()>);
8372impl<'a> Rect2DBuilder<'a> {
8373 #[inline]
8374 pub fn new() -> Rect2DBuilder<'a> {
8375 Rect2DBuilder(Default::default(), std::marker::PhantomData)
8376 }
8377 #[inline]
8378 #[must_use]
8379 pub fn offset(mut self, offset: crate::vk1_0::Offset2D) -> Self {
8380 self.0.offset = offset as _;
8381 self
8382 }
8383 #[inline]
8384 #[must_use]
8385 pub fn extent(mut self, extent: crate::vk1_0::Extent2D) -> Self {
8386 self.0.extent = extent as _;
8387 self
8388 }
8389 #[inline]
8390 pub fn build(self) -> Rect2D {
8391 self.0
8392 }
8393}
8394impl<'a> std::default::Default for Rect2DBuilder<'a> {
8395 fn default() -> Rect2DBuilder<'a> {
8396 Self::new()
8397 }
8398}
8399impl<'a> std::fmt::Debug for Rect2DBuilder<'a> {
8400 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8401 std::fmt::Debug::fmt(&self.0, f)
8402 }
8403}
8404impl<'a> std::ops::Deref for Rect2DBuilder<'a> {
8405 type Target = Rect2D;
8406 fn deref(&self) -> &Self::Target {
8407 &self.0
8408 }
8409}
8410impl<'a> std::ops::DerefMut for Rect2DBuilder<'a> {
8411 fn deref_mut(&mut self) -> &mut Self::Target {
8412 &mut self.0
8413 }
8414}
8415#[doc(alias = "VkClearRect")]
8417#[derive(Copy, Clone, Hash, PartialEq, Eq)]
8418#[repr(C)]
8419pub struct ClearRect {
8420 pub rect: crate::vk1_0::Rect2D,
8421 pub base_array_layer: u32,
8422 pub layer_count: u32,
8423}
8424impl Default for ClearRect {
8425 fn default() -> Self {
8426 Self {
8427 rect: Default::default(),
8428 base_array_layer: Default::default(),
8429 layer_count: Default::default(),
8430 }
8431 }
8432}
8433impl std::fmt::Debug for ClearRect {
8434 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8435 f.debug_struct("ClearRect")
8436 .field("rect", &self.rect)
8437 .field("base_array_layer", &self.base_array_layer)
8438 .field("layer_count", &self.layer_count)
8439 .finish()
8440 }
8441}
8442impl ClearRect {
8443 #[inline]
8444 pub fn into_builder<'a>(self) -> ClearRectBuilder<'a> {
8445 ClearRectBuilder(self, std::marker::PhantomData)
8446 }
8447}
8448#[derive(Copy, Clone)]
8449#[repr(transparent)]
8451pub struct ClearRectBuilder<'a>(ClearRect, std::marker::PhantomData<&'a ()>);
8452impl<'a> ClearRectBuilder<'a> {
8453 #[inline]
8454 pub fn new() -> ClearRectBuilder<'a> {
8455 ClearRectBuilder(Default::default(), std::marker::PhantomData)
8456 }
8457 #[inline]
8458 #[must_use]
8459 pub fn rect(mut self, rect: crate::vk1_0::Rect2D) -> Self {
8460 self.0.rect = rect as _;
8461 self
8462 }
8463 #[inline]
8464 #[must_use]
8465 pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
8466 self.0.base_array_layer = base_array_layer as _;
8467 self
8468 }
8469 #[inline]
8470 #[must_use]
8471 pub fn layer_count(mut self, layer_count: u32) -> Self {
8472 self.0.layer_count = layer_count as _;
8473 self
8474 }
8475 #[inline]
8476 pub fn build(self) -> ClearRect {
8477 self.0
8478 }
8479}
8480impl<'a> std::default::Default for ClearRectBuilder<'a> {
8481 fn default() -> ClearRectBuilder<'a> {
8482 Self::new()
8483 }
8484}
8485impl<'a> std::fmt::Debug for ClearRectBuilder<'a> {
8486 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8487 std::fmt::Debug::fmt(&self.0, f)
8488 }
8489}
8490impl<'a> std::ops::Deref for ClearRectBuilder<'a> {
8491 type Target = ClearRect;
8492 fn deref(&self) -> &Self::Target {
8493 &self.0
8494 }
8495}
8496impl<'a> std::ops::DerefMut for ClearRectBuilder<'a> {
8497 fn deref_mut(&mut self) -> &mut Self::Target {
8498 &mut self.0
8499 }
8500}
8501#[doc(alias = "VkComponentMapping")]
8503#[derive(Copy, Clone, Hash, PartialEq, Eq)]
8504#[repr(C)]
8505pub struct ComponentMapping {
8506 pub r: crate::vk1_0::ComponentSwizzle,
8507 pub g: crate::vk1_0::ComponentSwizzle,
8508 pub b: crate::vk1_0::ComponentSwizzle,
8509 pub a: crate::vk1_0::ComponentSwizzle,
8510}
8511impl Default for ComponentMapping {
8512 fn default() -> Self {
8513 Self {
8514 r: Default::default(),
8515 g: Default::default(),
8516 b: Default::default(),
8517 a: Default::default(),
8518 }
8519 }
8520}
8521impl std::fmt::Debug for ComponentMapping {
8522 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8523 f.debug_struct("ComponentMapping")
8524 .field("r", &self.r)
8525 .field("g", &self.g)
8526 .field("b", &self.b)
8527 .field("a", &self.a)
8528 .finish()
8529 }
8530}
8531impl ComponentMapping {
8532 #[inline]
8533 pub fn into_builder<'a>(self) -> ComponentMappingBuilder<'a> {
8534 ComponentMappingBuilder(self, std::marker::PhantomData)
8535 }
8536}
8537#[derive(Copy, Clone)]
8538#[repr(transparent)]
8540pub struct ComponentMappingBuilder<'a>(
8541 ComponentMapping,
8542 std::marker::PhantomData<&'a ()>,
8543);
8544impl<'a> ComponentMappingBuilder<'a> {
8545 #[inline]
8546 pub fn new() -> ComponentMappingBuilder<'a> {
8547 ComponentMappingBuilder(Default::default(), std::marker::PhantomData)
8548 }
8549 #[inline]
8550 #[must_use]
8551 pub fn r(mut self, r: crate::vk1_0::ComponentSwizzle) -> Self {
8552 self.0.r = r as _;
8553 self
8554 }
8555 #[inline]
8556 #[must_use]
8557 pub fn g(mut self, g: crate::vk1_0::ComponentSwizzle) -> Self {
8558 self.0.g = g as _;
8559 self
8560 }
8561 #[inline]
8562 #[must_use]
8563 pub fn b(mut self, b: crate::vk1_0::ComponentSwizzle) -> Self {
8564 self.0.b = b as _;
8565 self
8566 }
8567 #[inline]
8568 #[must_use]
8569 pub fn a(mut self, a: crate::vk1_0::ComponentSwizzle) -> Self {
8570 self.0.a = a as _;
8571 self
8572 }
8573 #[inline]
8574 pub fn build(self) -> ComponentMapping {
8575 self.0
8576 }
8577}
8578impl<'a> std::default::Default for ComponentMappingBuilder<'a> {
8579 fn default() -> ComponentMappingBuilder<'a> {
8580 Self::new()
8581 }
8582}
8583impl<'a> std::fmt::Debug for ComponentMappingBuilder<'a> {
8584 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8585 std::fmt::Debug::fmt(&self.0, f)
8586 }
8587}
8588impl<'a> std::ops::Deref for ComponentMappingBuilder<'a> {
8589 type Target = ComponentMapping;
8590 fn deref(&self) -> &Self::Target {
8591 &self.0
8592 }
8593}
8594impl<'a> std::ops::DerefMut for ComponentMappingBuilder<'a> {
8595 fn deref_mut(&mut self) -> &mut Self::Target {
8596 &mut self.0
8597 }
8598}
8599#[doc(alias = "VkPhysicalDeviceProperties")]
8601#[derive(Copy, Clone)]
8602#[repr(C)]
8603pub struct PhysicalDeviceProperties {
8604 pub api_version: u32,
8605 pub driver_version: u32,
8606 pub vendor_id: u32,
8607 pub device_id: u32,
8608 pub device_type: crate::vk1_0::PhysicalDeviceType,
8609 pub device_name: [std::os::raw::c_char; 256],
8610 pub pipeline_cache_uuid: [u8; 16],
8611 pub limits: crate::vk1_0::PhysicalDeviceLimits,
8612 pub sparse_properties: crate::vk1_0::PhysicalDeviceSparseProperties,
8613}
8614impl Default for PhysicalDeviceProperties {
8615 fn default() -> Self {
8616 Self {
8617 api_version: Default::default(),
8618 driver_version: Default::default(),
8619 vendor_id: Default::default(),
8620 device_id: Default::default(),
8621 device_type: Default::default(),
8622 device_name: unsafe { std::mem::zeroed() },
8623 pipeline_cache_uuid: unsafe { std::mem::zeroed() },
8624 limits: Default::default(),
8625 sparse_properties: Default::default(),
8626 }
8627 }
8628}
8629impl std::fmt::Debug for PhysicalDeviceProperties {
8630 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8631 f.debug_struct("PhysicalDeviceProperties")
8632 .field("api_version", &self.api_version)
8633 .field("driver_version", &self.driver_version)
8634 .field("vendor_id", &self.vendor_id)
8635 .field("device_id", &self.device_id)
8636 .field("device_type", &self.device_type)
8637 .field(
8638 "device_name",
8639 unsafe { &std::ffi::CStr::from_ptr(self.device_name.as_ptr()) },
8640 )
8641 .field("pipeline_cache_uuid", &self.pipeline_cache_uuid)
8642 .field("limits", &self.limits)
8643 .field("sparse_properties", &self.sparse_properties)
8644 .finish()
8645 }
8646}
8647impl PhysicalDeviceProperties {
8648 #[inline]
8649 pub fn into_builder<'a>(self) -> PhysicalDevicePropertiesBuilder<'a> {
8650 PhysicalDevicePropertiesBuilder(self, std::marker::PhantomData)
8651 }
8652}
8653#[derive(Copy, Clone)]
8654#[repr(transparent)]
8656pub struct PhysicalDevicePropertiesBuilder<'a>(
8657 PhysicalDeviceProperties,
8658 std::marker::PhantomData<&'a ()>,
8659);
8660impl<'a> PhysicalDevicePropertiesBuilder<'a> {
8661 #[inline]
8662 pub fn new() -> PhysicalDevicePropertiesBuilder<'a> {
8663 PhysicalDevicePropertiesBuilder(Default::default(), std::marker::PhantomData)
8664 }
8665 #[inline]
8666 #[must_use]
8667 pub fn api_version(mut self, api_version: u32) -> Self {
8668 self.0.api_version = api_version as _;
8669 self
8670 }
8671 #[inline]
8672 #[must_use]
8673 pub fn driver_version(mut self, driver_version: u32) -> Self {
8674 self.0.driver_version = driver_version as _;
8675 self
8676 }
8677 #[inline]
8678 #[must_use]
8679 pub fn vendor_id(mut self, vendor_id: u32) -> Self {
8680 self.0.vendor_id = vendor_id as _;
8681 self
8682 }
8683 #[inline]
8684 #[must_use]
8685 pub fn device_id(mut self, device_id: u32) -> Self {
8686 self.0.device_id = device_id as _;
8687 self
8688 }
8689 #[inline]
8690 #[must_use]
8691 pub fn device_type(mut self, device_type: crate::vk1_0::PhysicalDeviceType) -> Self {
8692 self.0.device_type = device_type as _;
8693 self
8694 }
8695 #[inline]
8696 #[must_use]
8697 pub fn device_name(mut self, device_name: [std::os::raw::c_char; 256]) -> Self {
8698 self.0.device_name = device_name as _;
8699 self
8700 }
8701 #[inline]
8702 #[must_use]
8703 pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; 16]) -> Self {
8704 self.0.pipeline_cache_uuid = pipeline_cache_uuid as _;
8705 self
8706 }
8707 #[inline]
8708 #[must_use]
8709 pub fn limits(mut self, limits: crate::vk1_0::PhysicalDeviceLimits) -> Self {
8710 self.0.limits = limits as _;
8711 self
8712 }
8713 #[inline]
8714 #[must_use]
8715 pub fn sparse_properties(
8716 mut self,
8717 sparse_properties: crate::vk1_0::PhysicalDeviceSparseProperties,
8718 ) -> Self {
8719 self.0.sparse_properties = sparse_properties as _;
8720 self
8721 }
8722 #[inline]
8723 pub fn build(self) -> PhysicalDeviceProperties {
8724 self.0
8725 }
8726}
8727impl<'a> std::default::Default for PhysicalDevicePropertiesBuilder<'a> {
8728 fn default() -> PhysicalDevicePropertiesBuilder<'a> {
8729 Self::new()
8730 }
8731}
8732impl<'a> std::fmt::Debug for PhysicalDevicePropertiesBuilder<'a> {
8733 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8734 std::fmt::Debug::fmt(&self.0, f)
8735 }
8736}
8737impl<'a> std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> {
8738 type Target = PhysicalDeviceProperties;
8739 fn deref(&self) -> &Self::Target {
8740 &self.0
8741 }
8742}
8743impl<'a> std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> {
8744 fn deref_mut(&mut self) -> &mut Self::Target {
8745 &mut self.0
8746 }
8747}
8748#[doc(alias = "VkExtensionProperties")]
8750#[derive(Copy, Clone, Hash, PartialEq, Eq)]
8751#[repr(C)]
8752pub struct ExtensionProperties {
8753 pub extension_name: [std::os::raw::c_char; 256],
8754 pub spec_version: u32,
8755}
8756impl Default for ExtensionProperties {
8757 fn default() -> Self {
8758 Self {
8759 extension_name: unsafe { std::mem::zeroed() },
8760 spec_version: Default::default(),
8761 }
8762 }
8763}
8764impl std::fmt::Debug for ExtensionProperties {
8765 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8766 f.debug_struct("ExtensionProperties")
8767 .field(
8768 "extension_name",
8769 unsafe { &std::ffi::CStr::from_ptr(self.extension_name.as_ptr()) },
8770 )
8771 .field("spec_version", &self.spec_version)
8772 .finish()
8773 }
8774}
8775impl ExtensionProperties {
8776 #[inline]
8777 pub fn into_builder<'a>(self) -> ExtensionPropertiesBuilder<'a> {
8778 ExtensionPropertiesBuilder(self, std::marker::PhantomData)
8779 }
8780}
8781#[derive(Copy, Clone)]
8782#[repr(transparent)]
8784pub struct ExtensionPropertiesBuilder<'a>(
8785 ExtensionProperties,
8786 std::marker::PhantomData<&'a ()>,
8787);
8788impl<'a> ExtensionPropertiesBuilder<'a> {
8789 #[inline]
8790 pub fn new() -> ExtensionPropertiesBuilder<'a> {
8791 ExtensionPropertiesBuilder(Default::default(), std::marker::PhantomData)
8792 }
8793 #[inline]
8794 #[must_use]
8795 pub fn extension_name(
8796 mut self,
8797 extension_name: [std::os::raw::c_char; 256],
8798 ) -> Self {
8799 self.0.extension_name = extension_name as _;
8800 self
8801 }
8802 #[inline]
8803 #[must_use]
8804 pub fn spec_version(mut self, spec_version: u32) -> Self {
8805 self.0.spec_version = spec_version as _;
8806 self
8807 }
8808 #[inline]
8809 pub fn build(self) -> ExtensionProperties {
8810 self.0
8811 }
8812}
8813impl<'a> std::default::Default for ExtensionPropertiesBuilder<'a> {
8814 fn default() -> ExtensionPropertiesBuilder<'a> {
8815 Self::new()
8816 }
8817}
8818impl<'a> std::fmt::Debug for ExtensionPropertiesBuilder<'a> {
8819 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8820 std::fmt::Debug::fmt(&self.0, f)
8821 }
8822}
8823impl<'a> std::ops::Deref for ExtensionPropertiesBuilder<'a> {
8824 type Target = ExtensionProperties;
8825 fn deref(&self) -> &Self::Target {
8826 &self.0
8827 }
8828}
8829impl<'a> std::ops::DerefMut for ExtensionPropertiesBuilder<'a> {
8830 fn deref_mut(&mut self) -> &mut Self::Target {
8831 &mut self.0
8832 }
8833}
8834#[doc(alias = "VkLayerProperties")]
8836#[derive(Copy, Clone, Hash, PartialEq, Eq)]
8837#[repr(C)]
8838pub struct LayerProperties {
8839 pub layer_name: [std::os::raw::c_char; 256],
8840 pub spec_version: u32,
8841 pub implementation_version: u32,
8842 pub description: [std::os::raw::c_char; 256],
8843}
8844impl Default for LayerProperties {
8845 fn default() -> Self {
8846 Self {
8847 layer_name: unsafe { std::mem::zeroed() },
8848 spec_version: Default::default(),
8849 implementation_version: Default::default(),
8850 description: unsafe { std::mem::zeroed() },
8851 }
8852 }
8853}
8854impl std::fmt::Debug for LayerProperties {
8855 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8856 f.debug_struct("LayerProperties")
8857 .field(
8858 "layer_name",
8859 unsafe { &std::ffi::CStr::from_ptr(self.layer_name.as_ptr()) },
8860 )
8861 .field("spec_version", &self.spec_version)
8862 .field("implementation_version", &self.implementation_version)
8863 .field(
8864 "description",
8865 unsafe { &std::ffi::CStr::from_ptr(self.description.as_ptr()) },
8866 )
8867 .finish()
8868 }
8869}
8870impl LayerProperties {
8871 #[inline]
8872 pub fn into_builder<'a>(self) -> LayerPropertiesBuilder<'a> {
8873 LayerPropertiesBuilder(self, std::marker::PhantomData)
8874 }
8875}
8876#[derive(Copy, Clone)]
8877#[repr(transparent)]
8879pub struct LayerPropertiesBuilder<'a>(LayerProperties, std::marker::PhantomData<&'a ()>);
8880impl<'a> LayerPropertiesBuilder<'a> {
8881 #[inline]
8882 pub fn new() -> LayerPropertiesBuilder<'a> {
8883 LayerPropertiesBuilder(Default::default(), std::marker::PhantomData)
8884 }
8885 #[inline]
8886 #[must_use]
8887 pub fn layer_name(mut self, layer_name: [std::os::raw::c_char; 256]) -> Self {
8888 self.0.layer_name = layer_name as _;
8889 self
8890 }
8891 #[inline]
8892 #[must_use]
8893 pub fn spec_version(mut self, spec_version: u32) -> Self {
8894 self.0.spec_version = spec_version as _;
8895 self
8896 }
8897 #[inline]
8898 #[must_use]
8899 pub fn implementation_version(mut self, implementation_version: u32) -> Self {
8900 self.0.implementation_version = implementation_version as _;
8901 self
8902 }
8903 #[inline]
8904 #[must_use]
8905 pub fn description(mut self, description: [std::os::raw::c_char; 256]) -> Self {
8906 self.0.description = description as _;
8907 self
8908 }
8909 #[inline]
8910 pub fn build(self) -> LayerProperties {
8911 self.0
8912 }
8913}
8914impl<'a> std::default::Default for LayerPropertiesBuilder<'a> {
8915 fn default() -> LayerPropertiesBuilder<'a> {
8916 Self::new()
8917 }
8918}
8919impl<'a> std::fmt::Debug for LayerPropertiesBuilder<'a> {
8920 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8921 std::fmt::Debug::fmt(&self.0, f)
8922 }
8923}
8924impl<'a> std::ops::Deref for LayerPropertiesBuilder<'a> {
8925 type Target = LayerProperties;
8926 fn deref(&self) -> &Self::Target {
8927 &self.0
8928 }
8929}
8930impl<'a> std::ops::DerefMut for LayerPropertiesBuilder<'a> {
8931 fn deref_mut(&mut self) -> &mut Self::Target {
8932 &mut self.0
8933 }
8934}
8935#[doc(alias = "VkApplicationInfo")]
8937#[derive(Copy, Clone)]
8938#[repr(C)]
8939pub struct ApplicationInfo {
8940 pub s_type: crate::vk1_0::StructureType,
8941 pub p_next: *const std::ffi::c_void,
8942 pub p_application_name: *const std::os::raw::c_char,
8943 pub application_version: u32,
8944 pub p_engine_name: *const std::os::raw::c_char,
8945 pub engine_version: u32,
8946 pub api_version: u32,
8947}
8948impl ApplicationInfo {
8949 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::APPLICATION_INFO;
8950}
8951impl Default for ApplicationInfo {
8952 fn default() -> Self {
8953 Self {
8954 s_type: Self::STRUCTURE_TYPE,
8955 p_next: std::ptr::null(),
8956 p_application_name: std::ptr::null(),
8957 application_version: Default::default(),
8958 p_engine_name: std::ptr::null(),
8959 engine_version: Default::default(),
8960 api_version: Default::default(),
8961 }
8962 }
8963}
8964impl std::fmt::Debug for ApplicationInfo {
8965 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
8966 f.debug_struct("ApplicationInfo")
8967 .field("s_type", &self.s_type)
8968 .field("p_next", &self.p_next)
8969 .field("p_application_name", &self.p_application_name)
8970 .field("application_version", &self.application_version)
8971 .field("p_engine_name", &self.p_engine_name)
8972 .field("engine_version", &self.engine_version)
8973 .field("api_version", &self.api_version)
8974 .finish()
8975 }
8976}
8977impl ApplicationInfo {
8978 #[inline]
8979 pub fn into_builder<'a>(self) -> ApplicationInfoBuilder<'a> {
8980 ApplicationInfoBuilder(self, std::marker::PhantomData)
8981 }
8982}
8983#[derive(Copy, Clone)]
8984#[repr(transparent)]
8986pub struct ApplicationInfoBuilder<'a>(ApplicationInfo, std::marker::PhantomData<&'a ()>);
8987impl<'a> ApplicationInfoBuilder<'a> {
8988 #[inline]
8989 pub fn new() -> ApplicationInfoBuilder<'a> {
8990 ApplicationInfoBuilder(Default::default(), std::marker::PhantomData)
8991 }
8992 #[inline]
8993 #[must_use]
8994 pub fn application_name(mut self, application_name: &'a std::ffi::CStr) -> Self {
8995 self.0.p_application_name = application_name.as_ptr();
8996 self
8997 }
8998 #[inline]
8999 #[must_use]
9000 pub fn application_version(mut self, application_version: u32) -> Self {
9001 self.0.application_version = application_version as _;
9002 self
9003 }
9004 #[inline]
9005 #[must_use]
9006 pub fn engine_name(mut self, engine_name: &'a std::ffi::CStr) -> Self {
9007 self.0.p_engine_name = engine_name.as_ptr();
9008 self
9009 }
9010 #[inline]
9011 #[must_use]
9012 pub fn engine_version(mut self, engine_version: u32) -> Self {
9013 self.0.engine_version = engine_version as _;
9014 self
9015 }
9016 #[inline]
9017 #[must_use]
9018 pub fn api_version(mut self, api_version: u32) -> Self {
9019 self.0.api_version = api_version as _;
9020 self
9021 }
9022 #[inline]
9023 pub fn build_dangling(self) -> ApplicationInfo {
9026 self.0
9027 }
9028}
9029impl<'a> std::default::Default for ApplicationInfoBuilder<'a> {
9030 fn default() -> ApplicationInfoBuilder<'a> {
9031 Self::new()
9032 }
9033}
9034impl<'a> std::fmt::Debug for ApplicationInfoBuilder<'a> {
9035 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9036 std::fmt::Debug::fmt(&self.0, f)
9037 }
9038}
9039impl<'a> std::ops::Deref for ApplicationInfoBuilder<'a> {
9040 type Target = ApplicationInfo;
9041 fn deref(&self) -> &Self::Target {
9042 &self.0
9043 }
9044}
9045impl<'a> std::ops::DerefMut for ApplicationInfoBuilder<'a> {
9046 fn deref_mut(&mut self) -> &mut Self::Target {
9047 &mut self.0
9048 }
9049}
9050#[doc(alias = "VkAllocationCallbacks")]
9052#[derive(Copy, Clone)]
9053#[repr(C)]
9054pub struct AllocationCallbacks {
9055 pub p_user_data: *mut std::ffi::c_void,
9056 pub pfn_allocation: Option<crate::vk1_0::PFN_vkAllocationFunction>,
9057 pub pfn_reallocation: Option<crate::vk1_0::PFN_vkReallocationFunction>,
9058 pub pfn_free: Option<crate::vk1_0::PFN_vkFreeFunction>,
9059 pub pfn_internal_allocation: Option<
9060 crate::vk1_0::PFN_vkInternalAllocationNotification,
9061 >,
9062 pub pfn_internal_free: Option<crate::vk1_0::PFN_vkInternalFreeNotification>,
9063}
9064impl Default for AllocationCallbacks {
9065 fn default() -> Self {
9066 Self {
9067 p_user_data: std::ptr::null_mut(),
9068 pfn_allocation: Default::default(),
9069 pfn_reallocation: Default::default(),
9070 pfn_free: Default::default(),
9071 pfn_internal_allocation: Default::default(),
9072 pfn_internal_free: Default::default(),
9073 }
9074 }
9075}
9076impl std::fmt::Debug for AllocationCallbacks {
9077 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9078 f.debug_struct("AllocationCallbacks")
9079 .field("p_user_data", &self.p_user_data)
9080 .field(
9081 "pfn_allocation",
9082 unsafe { &std::mem::transmute::<_, *const ()>(self.pfn_allocation) },
9083 )
9084 .field(
9085 "pfn_reallocation",
9086 unsafe { &std::mem::transmute::<_, *const ()>(self.pfn_reallocation) },
9087 )
9088 .field(
9089 "pfn_free",
9090 unsafe { &std::mem::transmute::<_, *const ()>(self.pfn_free) },
9091 )
9092 .field(
9093 "pfn_internal_allocation",
9094 unsafe {
9095 &std::mem::transmute::<_, *const ()>(self.pfn_internal_allocation)
9096 },
9097 )
9098 .field(
9099 "pfn_internal_free",
9100 unsafe { &std::mem::transmute::<_, *const ()>(self.pfn_internal_free) },
9101 )
9102 .finish()
9103 }
9104}
9105impl AllocationCallbacks {
9106 #[inline]
9107 pub fn into_builder<'a>(self) -> AllocationCallbacksBuilder<'a> {
9108 AllocationCallbacksBuilder(self, std::marker::PhantomData)
9109 }
9110}
9111#[derive(Copy, Clone)]
9112#[repr(transparent)]
9114pub struct AllocationCallbacksBuilder<'a>(
9115 AllocationCallbacks,
9116 std::marker::PhantomData<&'a ()>,
9117);
9118impl<'a> AllocationCallbacksBuilder<'a> {
9119 #[inline]
9120 pub fn new() -> AllocationCallbacksBuilder<'a> {
9121 AllocationCallbacksBuilder(Default::default(), std::marker::PhantomData)
9122 }
9123 #[inline]
9124 #[must_use]
9125 pub fn user_data(mut self, user_data: *mut std::ffi::c_void) -> Self {
9126 self.0.p_user_data = user_data;
9127 self
9128 }
9129 #[inline]
9130 #[must_use]
9131 pub fn pfn_allocation(
9132 mut self,
9133 pfn_allocation: Option<crate::vk1_0::PFN_vkAllocationFunction>,
9134 ) -> Self {
9135 self.0.pfn_allocation = pfn_allocation as _;
9136 self
9137 }
9138 #[inline]
9139 #[must_use]
9140 pub fn pfn_reallocation(
9141 mut self,
9142 pfn_reallocation: Option<crate::vk1_0::PFN_vkReallocationFunction>,
9143 ) -> Self {
9144 self.0.pfn_reallocation = pfn_reallocation as _;
9145 self
9146 }
9147 #[inline]
9148 #[must_use]
9149 pub fn pfn_free(
9150 mut self,
9151 pfn_free: Option<crate::vk1_0::PFN_vkFreeFunction>,
9152 ) -> Self {
9153 self.0.pfn_free = pfn_free as _;
9154 self
9155 }
9156 #[inline]
9157 #[must_use]
9158 pub fn pfn_internal_allocation(
9159 mut self,
9160 pfn_internal_allocation: Option<
9161 crate::vk1_0::PFN_vkInternalAllocationNotification,
9162 >,
9163 ) -> Self {
9164 self.0.pfn_internal_allocation = pfn_internal_allocation as _;
9165 self
9166 }
9167 #[inline]
9168 #[must_use]
9169 pub fn pfn_internal_free(
9170 mut self,
9171 pfn_internal_free: Option<crate::vk1_0::PFN_vkInternalFreeNotification>,
9172 ) -> Self {
9173 self.0.pfn_internal_free = pfn_internal_free as _;
9174 self
9175 }
9176 #[inline]
9177 pub fn build_dangling(self) -> AllocationCallbacks {
9180 self.0
9181 }
9182}
9183impl<'a> std::default::Default for AllocationCallbacksBuilder<'a> {
9184 fn default() -> AllocationCallbacksBuilder<'a> {
9185 Self::new()
9186 }
9187}
9188impl<'a> std::fmt::Debug for AllocationCallbacksBuilder<'a> {
9189 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9190 std::fmt::Debug::fmt(&self.0, f)
9191 }
9192}
9193impl<'a> std::ops::Deref for AllocationCallbacksBuilder<'a> {
9194 type Target = AllocationCallbacks;
9195 fn deref(&self) -> &Self::Target {
9196 &self.0
9197 }
9198}
9199impl<'a> std::ops::DerefMut for AllocationCallbacksBuilder<'a> {
9200 fn deref_mut(&mut self) -> &mut Self::Target {
9201 &mut self.0
9202 }
9203}
9204#[doc(alias = "VkDeviceQueueCreateInfo")]
9206#[derive(Copy, Clone)]
9207#[repr(C)]
9208pub struct DeviceQueueCreateInfo {
9209 pub s_type: crate::vk1_0::StructureType,
9210 pub p_next: *const std::ffi::c_void,
9211 pub flags: crate::vk1_0::DeviceQueueCreateFlags,
9212 pub queue_family_index: u32,
9213 pub queue_count: u32,
9214 pub p_queue_priorities: *const std::os::raw::c_float,
9215}
9216impl DeviceQueueCreateInfo {
9217 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::DEVICE_QUEUE_CREATE_INFO;
9218}
9219impl Default for DeviceQueueCreateInfo {
9220 fn default() -> Self {
9221 Self {
9222 s_type: Self::STRUCTURE_TYPE,
9223 p_next: std::ptr::null(),
9224 flags: Default::default(),
9225 queue_family_index: Default::default(),
9226 queue_count: Default::default(),
9227 p_queue_priorities: std::ptr::null(),
9228 }
9229 }
9230}
9231impl std::fmt::Debug for DeviceQueueCreateInfo {
9232 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9233 f.debug_struct("DeviceQueueCreateInfo")
9234 .field("s_type", &self.s_type)
9235 .field("p_next", &self.p_next)
9236 .field("flags", &self.flags)
9237 .field("queue_family_index", &self.queue_family_index)
9238 .field("queue_count", &self.queue_count)
9239 .field("p_queue_priorities", &self.p_queue_priorities)
9240 .finish()
9241 }
9242}
9243impl DeviceQueueCreateInfo {
9244 #[inline]
9245 pub fn into_builder<'a>(self) -> DeviceQueueCreateInfoBuilder<'a> {
9246 DeviceQueueCreateInfoBuilder(self, std::marker::PhantomData)
9247 }
9248}
9249#[derive(Copy, Clone)]
9250#[repr(transparent)]
9252pub struct DeviceQueueCreateInfoBuilder<'a>(
9253 DeviceQueueCreateInfo,
9254 std::marker::PhantomData<&'a ()>,
9255);
9256impl<'a> DeviceQueueCreateInfoBuilder<'a> {
9257 #[inline]
9258 pub fn new() -> DeviceQueueCreateInfoBuilder<'a> {
9259 DeviceQueueCreateInfoBuilder(Default::default(), std::marker::PhantomData)
9260 }
9261 #[inline]
9262 #[must_use]
9263 pub fn flags(mut self, flags: crate::vk1_0::DeviceQueueCreateFlags) -> Self {
9264 self.0.flags = flags as _;
9265 self
9266 }
9267 #[inline]
9268 #[must_use]
9269 pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
9270 self.0.queue_family_index = queue_family_index as _;
9271 self
9272 }
9273 #[inline]
9274 #[must_use]
9275 pub fn queue_priorities(
9276 mut self,
9277 queue_priorities: &'a [std::os::raw::c_float],
9278 ) -> Self {
9279 self.0.p_queue_priorities = queue_priorities.as_ptr() as _;
9280 self.0.queue_count = queue_priorities.len() as _;
9281 self
9282 }
9283 #[inline]
9284 pub fn build_dangling(self) -> DeviceQueueCreateInfo {
9287 self.0
9288 }
9289}
9290impl<'a> std::default::Default for DeviceQueueCreateInfoBuilder<'a> {
9291 fn default() -> DeviceQueueCreateInfoBuilder<'a> {
9292 Self::new()
9293 }
9294}
9295impl<'a> std::fmt::Debug for DeviceQueueCreateInfoBuilder<'a> {
9296 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9297 std::fmt::Debug::fmt(&self.0, f)
9298 }
9299}
9300impl<'a> std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> {
9301 type Target = DeviceQueueCreateInfo;
9302 fn deref(&self) -> &Self::Target {
9303 &self.0
9304 }
9305}
9306impl<'a> std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> {
9307 fn deref_mut(&mut self) -> &mut Self::Target {
9308 &mut self.0
9309 }
9310}
9311#[doc(alias = "VkDeviceCreateInfo")]
9313#[derive(Copy, Clone)]
9314#[repr(C)]
9315pub struct DeviceCreateInfo {
9316 pub s_type: crate::vk1_0::StructureType,
9317 pub p_next: *const std::ffi::c_void,
9318 pub flags: crate::vk1_0::DeviceCreateFlags,
9319 pub queue_create_info_count: u32,
9320 pub p_queue_create_infos: *const crate::vk1_0::DeviceQueueCreateInfo,
9321 pub enabled_layer_count: u32,
9322 pub pp_enabled_layer_names: *const *const std::os::raw::c_char,
9323 pub enabled_extension_count: u32,
9324 pub pp_enabled_extension_names: *const *const std::os::raw::c_char,
9325 pub p_enabled_features: *const crate::vk1_0::PhysicalDeviceFeatures,
9326}
9327impl DeviceCreateInfo {
9328 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::DEVICE_CREATE_INFO;
9329}
9330impl Default for DeviceCreateInfo {
9331 fn default() -> Self {
9332 Self {
9333 s_type: Self::STRUCTURE_TYPE,
9334 p_next: std::ptr::null(),
9335 flags: Default::default(),
9336 queue_create_info_count: Default::default(),
9337 p_queue_create_infos: std::ptr::null(),
9338 enabled_layer_count: Default::default(),
9339 pp_enabled_layer_names: std::ptr::null(),
9340 enabled_extension_count: Default::default(),
9341 pp_enabled_extension_names: std::ptr::null(),
9342 p_enabled_features: std::ptr::null(),
9343 }
9344 }
9345}
9346impl std::fmt::Debug for DeviceCreateInfo {
9347 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9348 f.debug_struct("DeviceCreateInfo")
9349 .field("s_type", &self.s_type)
9350 .field("p_next", &self.p_next)
9351 .field("flags", &self.flags)
9352 .field("queue_create_info_count", &self.queue_create_info_count)
9353 .field("p_queue_create_infos", &self.p_queue_create_infos)
9354 .field("enabled_layer_count", &self.enabled_layer_count)
9355 .field("pp_enabled_layer_names", &self.pp_enabled_layer_names)
9356 .field("enabled_extension_count", &self.enabled_extension_count)
9357 .field("pp_enabled_extension_names", &self.pp_enabled_extension_names)
9358 .field("p_enabled_features", &self.p_enabled_features)
9359 .finish()
9360 }
9361}
9362impl DeviceCreateInfo {
9363 #[inline]
9364 pub fn into_builder<'a>(self) -> DeviceCreateInfoBuilder<'a> {
9365 DeviceCreateInfoBuilder(self, std::marker::PhantomData)
9366 }
9367}
9368#[derive(Copy, Clone)]
9369#[repr(transparent)]
9371pub struct DeviceCreateInfoBuilder<'a>(
9372 DeviceCreateInfo,
9373 std::marker::PhantomData<&'a ()>,
9374);
9375impl<'a> DeviceCreateInfoBuilder<'a> {
9376 #[inline]
9377 pub fn new() -> DeviceCreateInfoBuilder<'a> {
9378 DeviceCreateInfoBuilder(Default::default(), std::marker::PhantomData)
9379 }
9380 #[inline]
9381 #[must_use]
9382 pub fn flags(mut self, flags: crate::vk1_0::DeviceCreateFlags) -> Self {
9383 self.0.flags = flags as _;
9384 self
9385 }
9386 #[inline]
9387 #[must_use]
9388 pub fn queue_create_infos(
9389 mut self,
9390 queue_create_infos: &'a [crate::vk1_0::DeviceQueueCreateInfoBuilder],
9391 ) -> Self {
9392 self.0.p_queue_create_infos = queue_create_infos.as_ptr() as _;
9393 self.0.queue_create_info_count = queue_create_infos.len() as _;
9394 self
9395 }
9396 #[inline]
9397 #[must_use]
9398 pub fn enabled_layer_names(
9399 mut self,
9400 enabled_layer_names: &'a [*const std::os::raw::c_char],
9401 ) -> Self {
9402 self.0.pp_enabled_layer_names = enabled_layer_names.as_ptr() as _;
9403 self.0.enabled_layer_count = enabled_layer_names.len() as _;
9404 self
9405 }
9406 #[inline]
9407 #[must_use]
9408 pub fn enabled_extension_names(
9409 mut self,
9410 enabled_extension_names: &'a [*const std::os::raw::c_char],
9411 ) -> Self {
9412 self.0.pp_enabled_extension_names = enabled_extension_names.as_ptr() as _;
9413 self.0.enabled_extension_count = enabled_extension_names.len() as _;
9414 self
9415 }
9416 #[inline]
9417 #[must_use]
9418 pub fn enabled_features(
9419 mut self,
9420 enabled_features: &'a crate::vk1_0::PhysicalDeviceFeatures,
9421 ) -> Self {
9422 self.0.p_enabled_features = enabled_features as _;
9423 self
9424 }
9425 #[inline]
9426 pub fn build_dangling(self) -> DeviceCreateInfo {
9429 self.0
9430 }
9431}
9432impl<'a> std::default::Default for DeviceCreateInfoBuilder<'a> {
9433 fn default() -> DeviceCreateInfoBuilder<'a> {
9434 Self::new()
9435 }
9436}
9437impl<'a> std::fmt::Debug for DeviceCreateInfoBuilder<'a> {
9438 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9439 std::fmt::Debug::fmt(&self.0, f)
9440 }
9441}
9442impl<'a> std::ops::Deref for DeviceCreateInfoBuilder<'a> {
9443 type Target = DeviceCreateInfo;
9444 fn deref(&self) -> &Self::Target {
9445 &self.0
9446 }
9447}
9448impl<'a> std::ops::DerefMut for DeviceCreateInfoBuilder<'a> {
9449 fn deref_mut(&mut self) -> &mut Self::Target {
9450 &mut self.0
9451 }
9452}
9453#[doc(alias = "VkInstanceCreateInfo")]
9455#[derive(Copy, Clone)]
9456#[repr(C)]
9457pub struct InstanceCreateInfo {
9458 pub s_type: crate::vk1_0::StructureType,
9459 pub p_next: *const std::ffi::c_void,
9460 pub flags: crate::vk1_0::InstanceCreateFlags,
9461 pub p_application_info: *const crate::vk1_0::ApplicationInfo,
9462 pub enabled_layer_count: u32,
9463 pub pp_enabled_layer_names: *const *const std::os::raw::c_char,
9464 pub enabled_extension_count: u32,
9465 pub pp_enabled_extension_names: *const *const std::os::raw::c_char,
9466}
9467impl InstanceCreateInfo {
9468 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::INSTANCE_CREATE_INFO;
9469}
9470impl Default for InstanceCreateInfo {
9471 fn default() -> Self {
9472 Self {
9473 s_type: Self::STRUCTURE_TYPE,
9474 p_next: std::ptr::null(),
9475 flags: Default::default(),
9476 p_application_info: std::ptr::null(),
9477 enabled_layer_count: Default::default(),
9478 pp_enabled_layer_names: std::ptr::null(),
9479 enabled_extension_count: Default::default(),
9480 pp_enabled_extension_names: std::ptr::null(),
9481 }
9482 }
9483}
9484impl std::fmt::Debug for InstanceCreateInfo {
9485 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9486 f.debug_struct("InstanceCreateInfo")
9487 .field("s_type", &self.s_type)
9488 .field("p_next", &self.p_next)
9489 .field("flags", &self.flags)
9490 .field("p_application_info", &self.p_application_info)
9491 .field("enabled_layer_count", &self.enabled_layer_count)
9492 .field("pp_enabled_layer_names", &self.pp_enabled_layer_names)
9493 .field("enabled_extension_count", &self.enabled_extension_count)
9494 .field("pp_enabled_extension_names", &self.pp_enabled_extension_names)
9495 .finish()
9496 }
9497}
9498impl InstanceCreateInfo {
9499 #[inline]
9500 pub fn into_builder<'a>(self) -> InstanceCreateInfoBuilder<'a> {
9501 InstanceCreateInfoBuilder(self, std::marker::PhantomData)
9502 }
9503}
9504#[derive(Copy, Clone)]
9505#[repr(transparent)]
9507pub struct InstanceCreateInfoBuilder<'a>(
9508 InstanceCreateInfo,
9509 std::marker::PhantomData<&'a ()>,
9510);
9511impl<'a> InstanceCreateInfoBuilder<'a> {
9512 #[inline]
9513 pub fn new() -> InstanceCreateInfoBuilder<'a> {
9514 InstanceCreateInfoBuilder(Default::default(), std::marker::PhantomData)
9515 }
9516 #[inline]
9517 #[must_use]
9518 pub fn flags(mut self, flags: crate::vk1_0::InstanceCreateFlags) -> Self {
9519 self.0.flags = flags as _;
9520 self
9521 }
9522 #[inline]
9523 #[must_use]
9524 pub fn application_info(
9525 mut self,
9526 application_info: &'a crate::vk1_0::ApplicationInfo,
9527 ) -> Self {
9528 self.0.p_application_info = application_info as _;
9529 self
9530 }
9531 #[inline]
9532 #[must_use]
9533 pub fn enabled_layer_names(
9534 mut self,
9535 enabled_layer_names: &'a [*const std::os::raw::c_char],
9536 ) -> Self {
9537 self.0.pp_enabled_layer_names = enabled_layer_names.as_ptr() as _;
9538 self.0.enabled_layer_count = enabled_layer_names.len() as _;
9539 self
9540 }
9541 #[inline]
9542 #[must_use]
9543 pub fn enabled_extension_names(
9544 mut self,
9545 enabled_extension_names: &'a [*const std::os::raw::c_char],
9546 ) -> Self {
9547 self.0.pp_enabled_extension_names = enabled_extension_names.as_ptr() as _;
9548 self.0.enabled_extension_count = enabled_extension_names.len() as _;
9549 self
9550 }
9551 #[inline]
9552 pub fn build_dangling(self) -> InstanceCreateInfo {
9555 self.0
9556 }
9557}
9558impl<'a> std::default::Default for InstanceCreateInfoBuilder<'a> {
9559 fn default() -> InstanceCreateInfoBuilder<'a> {
9560 Self::new()
9561 }
9562}
9563impl<'a> std::fmt::Debug for InstanceCreateInfoBuilder<'a> {
9564 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9565 std::fmt::Debug::fmt(&self.0, f)
9566 }
9567}
9568impl<'a> std::ops::Deref for InstanceCreateInfoBuilder<'a> {
9569 type Target = InstanceCreateInfo;
9570 fn deref(&self) -> &Self::Target {
9571 &self.0
9572 }
9573}
9574impl<'a> std::ops::DerefMut for InstanceCreateInfoBuilder<'a> {
9575 fn deref_mut(&mut self) -> &mut Self::Target {
9576 &mut self.0
9577 }
9578}
9579#[doc(alias = "VkQueueFamilyProperties")]
9581#[derive(Copy, Clone, Hash, PartialEq, Eq)]
9582#[repr(C)]
9583pub struct QueueFamilyProperties {
9584 pub queue_flags: crate::vk1_0::QueueFlags,
9585 pub queue_count: u32,
9586 pub timestamp_valid_bits: u32,
9587 pub min_image_transfer_granularity: crate::vk1_0::Extent3D,
9588}
9589impl Default for QueueFamilyProperties {
9590 fn default() -> Self {
9591 Self {
9592 queue_flags: Default::default(),
9593 queue_count: Default::default(),
9594 timestamp_valid_bits: Default::default(),
9595 min_image_transfer_granularity: Default::default(),
9596 }
9597 }
9598}
9599impl std::fmt::Debug for QueueFamilyProperties {
9600 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9601 f.debug_struct("QueueFamilyProperties")
9602 .field("queue_flags", &self.queue_flags)
9603 .field("queue_count", &self.queue_count)
9604 .field("timestamp_valid_bits", &self.timestamp_valid_bits)
9605 .field(
9606 "min_image_transfer_granularity",
9607 &self.min_image_transfer_granularity,
9608 )
9609 .finish()
9610 }
9611}
9612impl QueueFamilyProperties {
9613 #[inline]
9614 pub fn into_builder<'a>(self) -> QueueFamilyPropertiesBuilder<'a> {
9615 QueueFamilyPropertiesBuilder(self, std::marker::PhantomData)
9616 }
9617}
9618#[derive(Copy, Clone)]
9619#[repr(transparent)]
9621pub struct QueueFamilyPropertiesBuilder<'a>(
9622 QueueFamilyProperties,
9623 std::marker::PhantomData<&'a ()>,
9624);
9625impl<'a> QueueFamilyPropertiesBuilder<'a> {
9626 #[inline]
9627 pub fn new() -> QueueFamilyPropertiesBuilder<'a> {
9628 QueueFamilyPropertiesBuilder(Default::default(), std::marker::PhantomData)
9629 }
9630 #[inline]
9631 #[must_use]
9632 pub fn queue_flags(mut self, queue_flags: crate::vk1_0::QueueFlags) -> Self {
9633 self.0.queue_flags = queue_flags as _;
9634 self
9635 }
9636 #[inline]
9637 #[must_use]
9638 pub fn queue_count(mut self, queue_count: u32) -> Self {
9639 self.0.queue_count = queue_count as _;
9640 self
9641 }
9642 #[inline]
9643 #[must_use]
9644 pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self {
9645 self.0.timestamp_valid_bits = timestamp_valid_bits as _;
9646 self
9647 }
9648 #[inline]
9649 #[must_use]
9650 pub fn min_image_transfer_granularity(
9651 mut self,
9652 min_image_transfer_granularity: crate::vk1_0::Extent3D,
9653 ) -> Self {
9654 self.0.min_image_transfer_granularity = min_image_transfer_granularity as _;
9655 self
9656 }
9657 #[inline]
9658 pub fn build(self) -> QueueFamilyProperties {
9659 self.0
9660 }
9661}
9662impl<'a> std::default::Default for QueueFamilyPropertiesBuilder<'a> {
9663 fn default() -> QueueFamilyPropertiesBuilder<'a> {
9664 Self::new()
9665 }
9666}
9667impl<'a> std::fmt::Debug for QueueFamilyPropertiesBuilder<'a> {
9668 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9669 std::fmt::Debug::fmt(&self.0, f)
9670 }
9671}
9672impl<'a> std::ops::Deref for QueueFamilyPropertiesBuilder<'a> {
9673 type Target = QueueFamilyProperties;
9674 fn deref(&self) -> &Self::Target {
9675 &self.0
9676 }
9677}
9678impl<'a> std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> {
9679 fn deref_mut(&mut self) -> &mut Self::Target {
9680 &mut self.0
9681 }
9682}
9683#[doc(alias = "VkPhysicalDeviceMemoryProperties")]
9685#[derive(Copy, Clone, Hash, PartialEq, Eq)]
9686#[repr(C)]
9687pub struct PhysicalDeviceMemoryProperties {
9688 pub memory_type_count: u32,
9689 pub memory_types: [crate::vk1_0::MemoryType; 32],
9690 pub memory_heap_count: u32,
9691 pub memory_heaps: [crate::vk1_0::MemoryHeap; 16],
9692}
9693impl Default for PhysicalDeviceMemoryProperties {
9694 fn default() -> Self {
9695 Self {
9696 memory_type_count: Default::default(),
9697 memory_types: unsafe { std::mem::zeroed() },
9698 memory_heap_count: Default::default(),
9699 memory_heaps: unsafe { std::mem::zeroed() },
9700 }
9701 }
9702}
9703impl std::fmt::Debug for PhysicalDeviceMemoryProperties {
9704 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9705 f.debug_struct("PhysicalDeviceMemoryProperties")
9706 .field("memory_type_count", &self.memory_type_count)
9707 .field("memory_types", &self.memory_types)
9708 .field("memory_heap_count", &self.memory_heap_count)
9709 .field("memory_heaps", &self.memory_heaps)
9710 .finish()
9711 }
9712}
9713impl PhysicalDeviceMemoryProperties {
9714 #[inline]
9715 pub fn into_builder<'a>(self) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
9716 PhysicalDeviceMemoryPropertiesBuilder(self, std::marker::PhantomData)
9717 }
9718}
9719#[derive(Copy, Clone)]
9720#[repr(transparent)]
9722pub struct PhysicalDeviceMemoryPropertiesBuilder<'a>(
9723 PhysicalDeviceMemoryProperties,
9724 std::marker::PhantomData<&'a ()>,
9725);
9726impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> {
9727 #[inline]
9728 pub fn new() -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
9729 PhysicalDeviceMemoryPropertiesBuilder(
9730 Default::default(),
9731 std::marker::PhantomData,
9732 )
9733 }
9734 #[inline]
9735 #[must_use]
9736 pub fn memory_type_count(mut self, memory_type_count: u32) -> Self {
9737 self.0.memory_type_count = memory_type_count as _;
9738 self
9739 }
9740 #[inline]
9741 #[must_use]
9742 pub fn memory_types(mut self, memory_types: [crate::vk1_0::MemoryType; 32]) -> Self {
9743 self.0.memory_types = memory_types as _;
9744 self
9745 }
9746 #[inline]
9747 #[must_use]
9748 pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self {
9749 self.0.memory_heap_count = memory_heap_count as _;
9750 self
9751 }
9752 #[inline]
9753 #[must_use]
9754 pub fn memory_heaps(mut self, memory_heaps: [crate::vk1_0::MemoryHeap; 16]) -> Self {
9755 self.0.memory_heaps = memory_heaps as _;
9756 self
9757 }
9758 #[inline]
9759 pub fn build(self) -> PhysicalDeviceMemoryProperties {
9760 self.0
9761 }
9762}
9763impl<'a> std::default::Default for PhysicalDeviceMemoryPropertiesBuilder<'a> {
9764 fn default() -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
9765 Self::new()
9766 }
9767}
9768impl<'a> std::fmt::Debug for PhysicalDeviceMemoryPropertiesBuilder<'a> {
9769 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9770 std::fmt::Debug::fmt(&self.0, f)
9771 }
9772}
9773impl<'a> std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> {
9774 type Target = PhysicalDeviceMemoryProperties;
9775 fn deref(&self) -> &Self::Target {
9776 &self.0
9777 }
9778}
9779impl<'a> std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> {
9780 fn deref_mut(&mut self) -> &mut Self::Target {
9781 &mut self.0
9782 }
9783}
9784#[doc(alias = "VkMemoryAllocateInfo")]
9786#[derive(Copy, Clone)]
9787#[repr(C)]
9788pub struct MemoryAllocateInfo {
9789 pub s_type: crate::vk1_0::StructureType,
9790 pub p_next: *const std::ffi::c_void,
9791 pub allocation_size: crate::vk1_0::DeviceSize,
9792 pub memory_type_index: u32,
9793}
9794impl MemoryAllocateInfo {
9795 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::MEMORY_ALLOCATE_INFO;
9796}
9797impl Default for MemoryAllocateInfo {
9798 fn default() -> Self {
9799 Self {
9800 s_type: Self::STRUCTURE_TYPE,
9801 p_next: std::ptr::null(),
9802 allocation_size: Default::default(),
9803 memory_type_index: Default::default(),
9804 }
9805 }
9806}
9807impl std::fmt::Debug for MemoryAllocateInfo {
9808 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9809 f.debug_struct("MemoryAllocateInfo")
9810 .field("s_type", &self.s_type)
9811 .field("p_next", &self.p_next)
9812 .field("allocation_size", &self.allocation_size)
9813 .field("memory_type_index", &self.memory_type_index)
9814 .finish()
9815 }
9816}
9817impl MemoryAllocateInfo {
9818 #[inline]
9819 pub fn into_builder<'a>(self) -> MemoryAllocateInfoBuilder<'a> {
9820 MemoryAllocateInfoBuilder(self, std::marker::PhantomData)
9821 }
9822}
9823#[derive(Copy, Clone)]
9824#[repr(transparent)]
9826pub struct MemoryAllocateInfoBuilder<'a>(
9827 MemoryAllocateInfo,
9828 std::marker::PhantomData<&'a ()>,
9829);
9830impl<'a> MemoryAllocateInfoBuilder<'a> {
9831 #[inline]
9832 pub fn new() -> MemoryAllocateInfoBuilder<'a> {
9833 MemoryAllocateInfoBuilder(Default::default(), std::marker::PhantomData)
9834 }
9835 #[inline]
9836 #[must_use]
9837 pub fn allocation_size(mut self, allocation_size: crate::vk1_0::DeviceSize) -> Self {
9838 self.0.allocation_size = allocation_size as _;
9839 self
9840 }
9841 #[inline]
9842 #[must_use]
9843 pub fn memory_type_index(mut self, memory_type_index: u32) -> Self {
9844 self.0.memory_type_index = memory_type_index as _;
9845 self
9846 }
9847 #[inline]
9848 pub fn build_dangling(self) -> MemoryAllocateInfo {
9851 self.0
9852 }
9853}
9854impl<'a> std::default::Default for MemoryAllocateInfoBuilder<'a> {
9855 fn default() -> MemoryAllocateInfoBuilder<'a> {
9856 Self::new()
9857 }
9858}
9859impl<'a> std::fmt::Debug for MemoryAllocateInfoBuilder<'a> {
9860 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9861 std::fmt::Debug::fmt(&self.0, f)
9862 }
9863}
9864impl<'a> std::ops::Deref for MemoryAllocateInfoBuilder<'a> {
9865 type Target = MemoryAllocateInfo;
9866 fn deref(&self) -> &Self::Target {
9867 &self.0
9868 }
9869}
9870impl<'a> std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> {
9871 fn deref_mut(&mut self) -> &mut Self::Target {
9872 &mut self.0
9873 }
9874}
9875#[doc(alias = "VkMemoryRequirements")]
9877#[derive(Copy, Clone, Hash, PartialEq, Eq)]
9878#[repr(C)]
9879pub struct MemoryRequirements {
9880 pub size: crate::vk1_0::DeviceSize,
9881 pub alignment: crate::vk1_0::DeviceSize,
9882 pub memory_type_bits: u32,
9883}
9884impl Default for MemoryRequirements {
9885 fn default() -> Self {
9886 Self {
9887 size: Default::default(),
9888 alignment: Default::default(),
9889 memory_type_bits: Default::default(),
9890 }
9891 }
9892}
9893impl std::fmt::Debug for MemoryRequirements {
9894 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9895 f.debug_struct("MemoryRequirements")
9896 .field("size", &self.size)
9897 .field("alignment", &self.alignment)
9898 .field("memory_type_bits", &self.memory_type_bits)
9899 .finish()
9900 }
9901}
9902impl MemoryRequirements {
9903 #[inline]
9904 pub fn into_builder<'a>(self) -> MemoryRequirementsBuilder<'a> {
9905 MemoryRequirementsBuilder(self, std::marker::PhantomData)
9906 }
9907}
9908#[derive(Copy, Clone)]
9909#[repr(transparent)]
9911pub struct MemoryRequirementsBuilder<'a>(
9912 MemoryRequirements,
9913 std::marker::PhantomData<&'a ()>,
9914);
9915impl<'a> MemoryRequirementsBuilder<'a> {
9916 #[inline]
9917 pub fn new() -> MemoryRequirementsBuilder<'a> {
9918 MemoryRequirementsBuilder(Default::default(), std::marker::PhantomData)
9919 }
9920 #[inline]
9921 #[must_use]
9922 pub fn size(mut self, size: crate::vk1_0::DeviceSize) -> Self {
9923 self.0.size = size as _;
9924 self
9925 }
9926 #[inline]
9927 #[must_use]
9928 pub fn alignment(mut self, alignment: crate::vk1_0::DeviceSize) -> Self {
9929 self.0.alignment = alignment as _;
9930 self
9931 }
9932 #[inline]
9933 #[must_use]
9934 pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
9935 self.0.memory_type_bits = memory_type_bits as _;
9936 self
9937 }
9938 #[inline]
9939 pub fn build(self) -> MemoryRequirements {
9940 self.0
9941 }
9942}
9943impl<'a> std::default::Default for MemoryRequirementsBuilder<'a> {
9944 fn default() -> MemoryRequirementsBuilder<'a> {
9945 Self::new()
9946 }
9947}
9948impl<'a> std::fmt::Debug for MemoryRequirementsBuilder<'a> {
9949 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9950 std::fmt::Debug::fmt(&self.0, f)
9951 }
9952}
9953impl<'a> std::ops::Deref for MemoryRequirementsBuilder<'a> {
9954 type Target = MemoryRequirements;
9955 fn deref(&self) -> &Self::Target {
9956 &self.0
9957 }
9958}
9959impl<'a> std::ops::DerefMut for MemoryRequirementsBuilder<'a> {
9960 fn deref_mut(&mut self) -> &mut Self::Target {
9961 &mut self.0
9962 }
9963}
9964#[doc(alias = "VkSparseImageFormatProperties")]
9966#[derive(Copy, Clone, Hash, PartialEq, Eq)]
9967#[repr(C)]
9968pub struct SparseImageFormatProperties {
9969 pub aspect_mask: crate::vk1_0::ImageAspectFlags,
9970 pub image_granularity: crate::vk1_0::Extent3D,
9971 pub flags: crate::vk1_0::SparseImageFormatFlags,
9972}
9973impl Default for SparseImageFormatProperties {
9974 fn default() -> Self {
9975 Self {
9976 aspect_mask: Default::default(),
9977 image_granularity: Default::default(),
9978 flags: Default::default(),
9979 }
9980 }
9981}
9982impl std::fmt::Debug for SparseImageFormatProperties {
9983 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
9984 f.debug_struct("SparseImageFormatProperties")
9985 .field("aspect_mask", &self.aspect_mask)
9986 .field("image_granularity", &self.image_granularity)
9987 .field("flags", &self.flags)
9988 .finish()
9989 }
9990}
9991impl SparseImageFormatProperties {
9992 #[inline]
9993 pub fn into_builder<'a>(self) -> SparseImageFormatPropertiesBuilder<'a> {
9994 SparseImageFormatPropertiesBuilder(self, std::marker::PhantomData)
9995 }
9996}
9997#[derive(Copy, Clone)]
9998#[repr(transparent)]
10000pub struct SparseImageFormatPropertiesBuilder<'a>(
10001 SparseImageFormatProperties,
10002 std::marker::PhantomData<&'a ()>,
10003);
10004impl<'a> SparseImageFormatPropertiesBuilder<'a> {
10005 #[inline]
10006 pub fn new() -> SparseImageFormatPropertiesBuilder<'a> {
10007 SparseImageFormatPropertiesBuilder(Default::default(), std::marker::PhantomData)
10008 }
10009 #[inline]
10010 #[must_use]
10011 pub fn aspect_mask(mut self, aspect_mask: crate::vk1_0::ImageAspectFlags) -> Self {
10012 self.0.aspect_mask = aspect_mask as _;
10013 self
10014 }
10015 #[inline]
10016 #[must_use]
10017 pub fn image_granularity(
10018 mut self,
10019 image_granularity: crate::vk1_0::Extent3D,
10020 ) -> Self {
10021 self.0.image_granularity = image_granularity as _;
10022 self
10023 }
10024 #[inline]
10025 #[must_use]
10026 pub fn flags(mut self, flags: crate::vk1_0::SparseImageFormatFlags) -> Self {
10027 self.0.flags = flags as _;
10028 self
10029 }
10030 #[inline]
10031 pub fn build(self) -> SparseImageFormatProperties {
10032 self.0
10033 }
10034}
10035impl<'a> std::default::Default for SparseImageFormatPropertiesBuilder<'a> {
10036 fn default() -> SparseImageFormatPropertiesBuilder<'a> {
10037 Self::new()
10038 }
10039}
10040impl<'a> std::fmt::Debug for SparseImageFormatPropertiesBuilder<'a> {
10041 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10042 std::fmt::Debug::fmt(&self.0, f)
10043 }
10044}
10045impl<'a> std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> {
10046 type Target = SparseImageFormatProperties;
10047 fn deref(&self) -> &Self::Target {
10048 &self.0
10049 }
10050}
10051impl<'a> std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> {
10052 fn deref_mut(&mut self) -> &mut Self::Target {
10053 &mut self.0
10054 }
10055}
10056#[doc(alias = "VkSparseImageMemoryRequirements")]
10058#[derive(Copy, Clone, Hash, PartialEq, Eq)]
10059#[repr(C)]
10060pub struct SparseImageMemoryRequirements {
10061 pub format_properties: crate::vk1_0::SparseImageFormatProperties,
10062 pub image_mip_tail_first_lod: u32,
10063 pub image_mip_tail_size: crate::vk1_0::DeviceSize,
10064 pub image_mip_tail_offset: crate::vk1_0::DeviceSize,
10065 pub image_mip_tail_stride: crate::vk1_0::DeviceSize,
10066}
10067impl Default for SparseImageMemoryRequirements {
10068 fn default() -> Self {
10069 Self {
10070 format_properties: Default::default(),
10071 image_mip_tail_first_lod: Default::default(),
10072 image_mip_tail_size: Default::default(),
10073 image_mip_tail_offset: Default::default(),
10074 image_mip_tail_stride: Default::default(),
10075 }
10076 }
10077}
10078impl std::fmt::Debug for SparseImageMemoryRequirements {
10079 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10080 f.debug_struct("SparseImageMemoryRequirements")
10081 .field("format_properties", &self.format_properties)
10082 .field("image_mip_tail_first_lod", &self.image_mip_tail_first_lod)
10083 .field("image_mip_tail_size", &self.image_mip_tail_size)
10084 .field("image_mip_tail_offset", &self.image_mip_tail_offset)
10085 .field("image_mip_tail_stride", &self.image_mip_tail_stride)
10086 .finish()
10087 }
10088}
10089impl SparseImageMemoryRequirements {
10090 #[inline]
10091 pub fn into_builder<'a>(self) -> SparseImageMemoryRequirementsBuilder<'a> {
10092 SparseImageMemoryRequirementsBuilder(self, std::marker::PhantomData)
10093 }
10094}
10095#[derive(Copy, Clone)]
10096#[repr(transparent)]
10098pub struct SparseImageMemoryRequirementsBuilder<'a>(
10099 SparseImageMemoryRequirements,
10100 std::marker::PhantomData<&'a ()>,
10101);
10102impl<'a> SparseImageMemoryRequirementsBuilder<'a> {
10103 #[inline]
10104 pub fn new() -> SparseImageMemoryRequirementsBuilder<'a> {
10105 SparseImageMemoryRequirementsBuilder(
10106 Default::default(),
10107 std::marker::PhantomData,
10108 )
10109 }
10110 #[inline]
10111 #[must_use]
10112 pub fn format_properties(
10113 mut self,
10114 format_properties: crate::vk1_0::SparseImageFormatProperties,
10115 ) -> Self {
10116 self.0.format_properties = format_properties as _;
10117 self
10118 }
10119 #[inline]
10120 #[must_use]
10121 pub fn image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self {
10122 self.0.image_mip_tail_first_lod = image_mip_tail_first_lod as _;
10123 self
10124 }
10125 #[inline]
10126 #[must_use]
10127 pub fn image_mip_tail_size(
10128 mut self,
10129 image_mip_tail_size: crate::vk1_0::DeviceSize,
10130 ) -> Self {
10131 self.0.image_mip_tail_size = image_mip_tail_size as _;
10132 self
10133 }
10134 #[inline]
10135 #[must_use]
10136 pub fn image_mip_tail_offset(
10137 mut self,
10138 image_mip_tail_offset: crate::vk1_0::DeviceSize,
10139 ) -> Self {
10140 self.0.image_mip_tail_offset = image_mip_tail_offset as _;
10141 self
10142 }
10143 #[inline]
10144 #[must_use]
10145 pub fn image_mip_tail_stride(
10146 mut self,
10147 image_mip_tail_stride: crate::vk1_0::DeviceSize,
10148 ) -> Self {
10149 self.0.image_mip_tail_stride = image_mip_tail_stride as _;
10150 self
10151 }
10152 #[inline]
10153 pub fn build(self) -> SparseImageMemoryRequirements {
10154 self.0
10155 }
10156}
10157impl<'a> std::default::Default for SparseImageMemoryRequirementsBuilder<'a> {
10158 fn default() -> SparseImageMemoryRequirementsBuilder<'a> {
10159 Self::new()
10160 }
10161}
10162impl<'a> std::fmt::Debug for SparseImageMemoryRequirementsBuilder<'a> {
10163 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10164 std::fmt::Debug::fmt(&self.0, f)
10165 }
10166}
10167impl<'a> std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> {
10168 type Target = SparseImageMemoryRequirements;
10169 fn deref(&self) -> &Self::Target {
10170 &self.0
10171 }
10172}
10173impl<'a> std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> {
10174 fn deref_mut(&mut self) -> &mut Self::Target {
10175 &mut self.0
10176 }
10177}
10178#[doc(alias = "VkMemoryType")]
10180#[derive(Copy, Clone, Hash, PartialEq, Eq)]
10181#[repr(C)]
10182pub struct MemoryType {
10183 pub property_flags: crate::vk1_0::MemoryPropertyFlags,
10184 pub heap_index: u32,
10185}
10186impl Default for MemoryType {
10187 fn default() -> Self {
10188 Self {
10189 property_flags: Default::default(),
10190 heap_index: Default::default(),
10191 }
10192 }
10193}
10194impl std::fmt::Debug for MemoryType {
10195 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10196 f.debug_struct("MemoryType")
10197 .field("property_flags", &self.property_flags)
10198 .field("heap_index", &self.heap_index)
10199 .finish()
10200 }
10201}
10202impl MemoryType {
10203 #[inline]
10204 pub fn into_builder<'a>(self) -> MemoryTypeBuilder<'a> {
10205 MemoryTypeBuilder(self, std::marker::PhantomData)
10206 }
10207}
10208#[derive(Copy, Clone)]
10209#[repr(transparent)]
10211pub struct MemoryTypeBuilder<'a>(MemoryType, std::marker::PhantomData<&'a ()>);
10212impl<'a> MemoryTypeBuilder<'a> {
10213 #[inline]
10214 pub fn new() -> MemoryTypeBuilder<'a> {
10215 MemoryTypeBuilder(Default::default(), std::marker::PhantomData)
10216 }
10217 #[inline]
10218 #[must_use]
10219 pub fn property_flags(
10220 mut self,
10221 property_flags: crate::vk1_0::MemoryPropertyFlags,
10222 ) -> Self {
10223 self.0.property_flags = property_flags as _;
10224 self
10225 }
10226 #[inline]
10227 #[must_use]
10228 pub fn heap_index(mut self, heap_index: u32) -> Self {
10229 self.0.heap_index = heap_index as _;
10230 self
10231 }
10232 #[inline]
10233 pub fn build(self) -> MemoryType {
10234 self.0
10235 }
10236}
10237impl<'a> std::default::Default for MemoryTypeBuilder<'a> {
10238 fn default() -> MemoryTypeBuilder<'a> {
10239 Self::new()
10240 }
10241}
10242impl<'a> std::fmt::Debug for MemoryTypeBuilder<'a> {
10243 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10244 std::fmt::Debug::fmt(&self.0, f)
10245 }
10246}
10247impl<'a> std::ops::Deref for MemoryTypeBuilder<'a> {
10248 type Target = MemoryType;
10249 fn deref(&self) -> &Self::Target {
10250 &self.0
10251 }
10252}
10253impl<'a> std::ops::DerefMut for MemoryTypeBuilder<'a> {
10254 fn deref_mut(&mut self) -> &mut Self::Target {
10255 &mut self.0
10256 }
10257}
10258#[doc(alias = "VkMemoryHeap")]
10260#[derive(Copy, Clone, Hash, PartialEq, Eq)]
10261#[repr(C)]
10262pub struct MemoryHeap {
10263 pub size: crate::vk1_0::DeviceSize,
10264 pub flags: crate::vk1_0::MemoryHeapFlags,
10265}
10266impl Default for MemoryHeap {
10267 fn default() -> Self {
10268 Self {
10269 size: Default::default(),
10270 flags: Default::default(),
10271 }
10272 }
10273}
10274impl std::fmt::Debug for MemoryHeap {
10275 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10276 f.debug_struct("MemoryHeap")
10277 .field("size", &self.size)
10278 .field("flags", &self.flags)
10279 .finish()
10280 }
10281}
10282impl MemoryHeap {
10283 #[inline]
10284 pub fn into_builder<'a>(self) -> MemoryHeapBuilder<'a> {
10285 MemoryHeapBuilder(self, std::marker::PhantomData)
10286 }
10287}
10288#[derive(Copy, Clone)]
10289#[repr(transparent)]
10291pub struct MemoryHeapBuilder<'a>(MemoryHeap, std::marker::PhantomData<&'a ()>);
10292impl<'a> MemoryHeapBuilder<'a> {
10293 #[inline]
10294 pub fn new() -> MemoryHeapBuilder<'a> {
10295 MemoryHeapBuilder(Default::default(), std::marker::PhantomData)
10296 }
10297 #[inline]
10298 #[must_use]
10299 pub fn size(mut self, size: crate::vk1_0::DeviceSize) -> Self {
10300 self.0.size = size as _;
10301 self
10302 }
10303 #[inline]
10304 #[must_use]
10305 pub fn flags(mut self, flags: crate::vk1_0::MemoryHeapFlags) -> Self {
10306 self.0.flags = flags as _;
10307 self
10308 }
10309 #[inline]
10310 pub fn build(self) -> MemoryHeap {
10311 self.0
10312 }
10313}
10314impl<'a> std::default::Default for MemoryHeapBuilder<'a> {
10315 fn default() -> MemoryHeapBuilder<'a> {
10316 Self::new()
10317 }
10318}
10319impl<'a> std::fmt::Debug for MemoryHeapBuilder<'a> {
10320 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10321 std::fmt::Debug::fmt(&self.0, f)
10322 }
10323}
10324impl<'a> std::ops::Deref for MemoryHeapBuilder<'a> {
10325 type Target = MemoryHeap;
10326 fn deref(&self) -> &Self::Target {
10327 &self.0
10328 }
10329}
10330impl<'a> std::ops::DerefMut for MemoryHeapBuilder<'a> {
10331 fn deref_mut(&mut self) -> &mut Self::Target {
10332 &mut self.0
10333 }
10334}
10335#[doc(alias = "VkMappedMemoryRange")]
10337#[derive(Copy, Clone)]
10338#[repr(C)]
10339pub struct MappedMemoryRange {
10340 pub s_type: crate::vk1_0::StructureType,
10341 pub p_next: *const std::ffi::c_void,
10342 pub memory: crate::vk1_0::DeviceMemory,
10343 pub offset: crate::vk1_0::DeviceSize,
10344 pub size: crate::vk1_0::DeviceSize,
10345}
10346impl MappedMemoryRange {
10347 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::MAPPED_MEMORY_RANGE;
10348}
10349impl Default for MappedMemoryRange {
10350 fn default() -> Self {
10351 Self {
10352 s_type: Self::STRUCTURE_TYPE,
10353 p_next: std::ptr::null(),
10354 memory: Default::default(),
10355 offset: Default::default(),
10356 size: Default::default(),
10357 }
10358 }
10359}
10360impl std::fmt::Debug for MappedMemoryRange {
10361 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10362 f.debug_struct("MappedMemoryRange")
10363 .field("s_type", &self.s_type)
10364 .field("p_next", &self.p_next)
10365 .field("memory", &self.memory)
10366 .field("offset", &self.offset)
10367 .field("size", &self.size)
10368 .finish()
10369 }
10370}
10371impl MappedMemoryRange {
10372 #[inline]
10373 pub fn into_builder<'a>(self) -> MappedMemoryRangeBuilder<'a> {
10374 MappedMemoryRangeBuilder(self, std::marker::PhantomData)
10375 }
10376}
10377#[derive(Copy, Clone)]
10378#[repr(transparent)]
10380pub struct MappedMemoryRangeBuilder<'a>(
10381 MappedMemoryRange,
10382 std::marker::PhantomData<&'a ()>,
10383);
10384impl<'a> MappedMemoryRangeBuilder<'a> {
10385 #[inline]
10386 pub fn new() -> MappedMemoryRangeBuilder<'a> {
10387 MappedMemoryRangeBuilder(Default::default(), std::marker::PhantomData)
10388 }
10389 #[inline]
10390 #[must_use]
10391 pub fn memory(mut self, memory: crate::vk1_0::DeviceMemory) -> Self {
10392 self.0.memory = memory as _;
10393 self
10394 }
10395 #[inline]
10396 #[must_use]
10397 pub fn offset(mut self, offset: crate::vk1_0::DeviceSize) -> Self {
10398 self.0.offset = offset as _;
10399 self
10400 }
10401 #[inline]
10402 #[must_use]
10403 pub fn size(mut self, size: crate::vk1_0::DeviceSize) -> Self {
10404 self.0.size = size as _;
10405 self
10406 }
10407 #[inline]
10408 pub fn build_dangling(self) -> MappedMemoryRange {
10411 self.0
10412 }
10413}
10414impl<'a> std::default::Default for MappedMemoryRangeBuilder<'a> {
10415 fn default() -> MappedMemoryRangeBuilder<'a> {
10416 Self::new()
10417 }
10418}
10419impl<'a> std::fmt::Debug for MappedMemoryRangeBuilder<'a> {
10420 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10421 std::fmt::Debug::fmt(&self.0, f)
10422 }
10423}
10424impl<'a> std::ops::Deref for MappedMemoryRangeBuilder<'a> {
10425 type Target = MappedMemoryRange;
10426 fn deref(&self) -> &Self::Target {
10427 &self.0
10428 }
10429}
10430impl<'a> std::ops::DerefMut for MappedMemoryRangeBuilder<'a> {
10431 fn deref_mut(&mut self) -> &mut Self::Target {
10432 &mut self.0
10433 }
10434}
10435#[doc(alias = "VkFormatProperties")]
10437#[derive(Copy, Clone, Hash, PartialEq, Eq)]
10438#[repr(C)]
10439pub struct FormatProperties {
10440 pub linear_tiling_features: crate::vk1_0::FormatFeatureFlags,
10441 pub optimal_tiling_features: crate::vk1_0::FormatFeatureFlags,
10442 pub buffer_features: crate::vk1_0::FormatFeatureFlags,
10443}
10444impl Default for FormatProperties {
10445 fn default() -> Self {
10446 Self {
10447 linear_tiling_features: Default::default(),
10448 optimal_tiling_features: Default::default(),
10449 buffer_features: Default::default(),
10450 }
10451 }
10452}
10453impl std::fmt::Debug for FormatProperties {
10454 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10455 f.debug_struct("FormatProperties")
10456 .field("linear_tiling_features", &self.linear_tiling_features)
10457 .field("optimal_tiling_features", &self.optimal_tiling_features)
10458 .field("buffer_features", &self.buffer_features)
10459 .finish()
10460 }
10461}
10462impl FormatProperties {
10463 #[inline]
10464 pub fn into_builder<'a>(self) -> FormatPropertiesBuilder<'a> {
10465 FormatPropertiesBuilder(self, std::marker::PhantomData)
10466 }
10467}
10468#[derive(Copy, Clone)]
10469#[repr(transparent)]
10471pub struct FormatPropertiesBuilder<'a>(
10472 FormatProperties,
10473 std::marker::PhantomData<&'a ()>,
10474);
10475impl<'a> FormatPropertiesBuilder<'a> {
10476 #[inline]
10477 pub fn new() -> FormatPropertiesBuilder<'a> {
10478 FormatPropertiesBuilder(Default::default(), std::marker::PhantomData)
10479 }
10480 #[inline]
10481 #[must_use]
10482 pub fn linear_tiling_features(
10483 mut self,
10484 linear_tiling_features: crate::vk1_0::FormatFeatureFlags,
10485 ) -> Self {
10486 self.0.linear_tiling_features = linear_tiling_features as _;
10487 self
10488 }
10489 #[inline]
10490 #[must_use]
10491 pub fn optimal_tiling_features(
10492 mut self,
10493 optimal_tiling_features: crate::vk1_0::FormatFeatureFlags,
10494 ) -> Self {
10495 self.0.optimal_tiling_features = optimal_tiling_features as _;
10496 self
10497 }
10498 #[inline]
10499 #[must_use]
10500 pub fn buffer_features(
10501 mut self,
10502 buffer_features: crate::vk1_0::FormatFeatureFlags,
10503 ) -> Self {
10504 self.0.buffer_features = buffer_features as _;
10505 self
10506 }
10507 #[inline]
10508 pub fn build(self) -> FormatProperties {
10509 self.0
10510 }
10511}
10512impl<'a> std::default::Default for FormatPropertiesBuilder<'a> {
10513 fn default() -> FormatPropertiesBuilder<'a> {
10514 Self::new()
10515 }
10516}
10517impl<'a> std::fmt::Debug for FormatPropertiesBuilder<'a> {
10518 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10519 std::fmt::Debug::fmt(&self.0, f)
10520 }
10521}
10522impl<'a> std::ops::Deref for FormatPropertiesBuilder<'a> {
10523 type Target = FormatProperties;
10524 fn deref(&self) -> &Self::Target {
10525 &self.0
10526 }
10527}
10528impl<'a> std::ops::DerefMut for FormatPropertiesBuilder<'a> {
10529 fn deref_mut(&mut self) -> &mut Self::Target {
10530 &mut self.0
10531 }
10532}
10533#[doc(alias = "VkImageFormatProperties")]
10535#[derive(Copy, Clone, Hash, PartialEq, Eq)]
10536#[repr(C)]
10537pub struct ImageFormatProperties {
10538 pub max_extent: crate::vk1_0::Extent3D,
10539 pub max_mip_levels: u32,
10540 pub max_array_layers: u32,
10541 pub sample_counts: crate::vk1_0::SampleCountFlags,
10542 pub max_resource_size: crate::vk1_0::DeviceSize,
10543}
10544impl Default for ImageFormatProperties {
10545 fn default() -> Self {
10546 Self {
10547 max_extent: Default::default(),
10548 max_mip_levels: Default::default(),
10549 max_array_layers: Default::default(),
10550 sample_counts: Default::default(),
10551 max_resource_size: Default::default(),
10552 }
10553 }
10554}
10555impl std::fmt::Debug for ImageFormatProperties {
10556 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10557 f.debug_struct("ImageFormatProperties")
10558 .field("max_extent", &self.max_extent)
10559 .field("max_mip_levels", &self.max_mip_levels)
10560 .field("max_array_layers", &self.max_array_layers)
10561 .field("sample_counts", &self.sample_counts)
10562 .field("max_resource_size", &self.max_resource_size)
10563 .finish()
10564 }
10565}
10566impl ImageFormatProperties {
10567 #[inline]
10568 pub fn into_builder<'a>(self) -> ImageFormatPropertiesBuilder<'a> {
10569 ImageFormatPropertiesBuilder(self, std::marker::PhantomData)
10570 }
10571}
10572#[derive(Copy, Clone)]
10573#[repr(transparent)]
10575pub struct ImageFormatPropertiesBuilder<'a>(
10576 ImageFormatProperties,
10577 std::marker::PhantomData<&'a ()>,
10578);
10579impl<'a> ImageFormatPropertiesBuilder<'a> {
10580 #[inline]
10581 pub fn new() -> ImageFormatPropertiesBuilder<'a> {
10582 ImageFormatPropertiesBuilder(Default::default(), std::marker::PhantomData)
10583 }
10584 #[inline]
10585 #[must_use]
10586 pub fn max_extent(mut self, max_extent: crate::vk1_0::Extent3D) -> Self {
10587 self.0.max_extent = max_extent as _;
10588 self
10589 }
10590 #[inline]
10591 #[must_use]
10592 pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self {
10593 self.0.max_mip_levels = max_mip_levels as _;
10594 self
10595 }
10596 #[inline]
10597 #[must_use]
10598 pub fn max_array_layers(mut self, max_array_layers: u32) -> Self {
10599 self.0.max_array_layers = max_array_layers as _;
10600 self
10601 }
10602 #[inline]
10603 #[must_use]
10604 pub fn sample_counts(
10605 mut self,
10606 sample_counts: crate::vk1_0::SampleCountFlags,
10607 ) -> Self {
10608 self.0.sample_counts = sample_counts as _;
10609 self
10610 }
10611 #[inline]
10612 #[must_use]
10613 pub fn max_resource_size(
10614 mut self,
10615 max_resource_size: crate::vk1_0::DeviceSize,
10616 ) -> Self {
10617 self.0.max_resource_size = max_resource_size as _;
10618 self
10619 }
10620 #[inline]
10621 pub fn build(self) -> ImageFormatProperties {
10622 self.0
10623 }
10624}
10625impl<'a> std::default::Default for ImageFormatPropertiesBuilder<'a> {
10626 fn default() -> ImageFormatPropertiesBuilder<'a> {
10627 Self::new()
10628 }
10629}
10630impl<'a> std::fmt::Debug for ImageFormatPropertiesBuilder<'a> {
10631 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10632 std::fmt::Debug::fmt(&self.0, f)
10633 }
10634}
10635impl<'a> std::ops::Deref for ImageFormatPropertiesBuilder<'a> {
10636 type Target = ImageFormatProperties;
10637 fn deref(&self) -> &Self::Target {
10638 &self.0
10639 }
10640}
10641impl<'a> std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> {
10642 fn deref_mut(&mut self) -> &mut Self::Target {
10643 &mut self.0
10644 }
10645}
10646#[doc(alias = "VkDescriptorBufferInfo")]
10648#[derive(Copy, Clone, Hash, PartialEq, Eq)]
10649#[repr(C)]
10650pub struct DescriptorBufferInfo {
10651 pub buffer: crate::vk1_0::Buffer,
10652 pub offset: crate::vk1_0::DeviceSize,
10653 pub range: crate::vk1_0::DeviceSize,
10654}
10655impl Default for DescriptorBufferInfo {
10656 fn default() -> Self {
10657 Self {
10658 buffer: Default::default(),
10659 offset: Default::default(),
10660 range: Default::default(),
10661 }
10662 }
10663}
10664impl std::fmt::Debug for DescriptorBufferInfo {
10665 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10666 f.debug_struct("DescriptorBufferInfo")
10667 .field("buffer", &self.buffer)
10668 .field("offset", &self.offset)
10669 .field("range", &self.range)
10670 .finish()
10671 }
10672}
10673impl DescriptorBufferInfo {
10674 #[inline]
10675 pub fn into_builder<'a>(self) -> DescriptorBufferInfoBuilder<'a> {
10676 DescriptorBufferInfoBuilder(self, std::marker::PhantomData)
10677 }
10678}
10679#[derive(Copy, Clone)]
10680#[repr(transparent)]
10682pub struct DescriptorBufferInfoBuilder<'a>(
10683 DescriptorBufferInfo,
10684 std::marker::PhantomData<&'a ()>,
10685);
10686impl<'a> DescriptorBufferInfoBuilder<'a> {
10687 #[inline]
10688 pub fn new() -> DescriptorBufferInfoBuilder<'a> {
10689 DescriptorBufferInfoBuilder(Default::default(), std::marker::PhantomData)
10690 }
10691 #[inline]
10692 #[must_use]
10693 pub fn buffer(mut self, buffer: crate::vk1_0::Buffer) -> Self {
10694 self.0.buffer = buffer as _;
10695 self
10696 }
10697 #[inline]
10698 #[must_use]
10699 pub fn offset(mut self, offset: crate::vk1_0::DeviceSize) -> Self {
10700 self.0.offset = offset as _;
10701 self
10702 }
10703 #[inline]
10704 #[must_use]
10705 pub fn range(mut self, range: crate::vk1_0::DeviceSize) -> Self {
10706 self.0.range = range as _;
10707 self
10708 }
10709 #[inline]
10710 pub fn build(self) -> DescriptorBufferInfo {
10711 self.0
10712 }
10713}
10714impl<'a> std::default::Default for DescriptorBufferInfoBuilder<'a> {
10715 fn default() -> DescriptorBufferInfoBuilder<'a> {
10716 Self::new()
10717 }
10718}
10719impl<'a> std::fmt::Debug for DescriptorBufferInfoBuilder<'a> {
10720 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10721 std::fmt::Debug::fmt(&self.0, f)
10722 }
10723}
10724impl<'a> std::ops::Deref for DescriptorBufferInfoBuilder<'a> {
10725 type Target = DescriptorBufferInfo;
10726 fn deref(&self) -> &Self::Target {
10727 &self.0
10728 }
10729}
10730impl<'a> std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> {
10731 fn deref_mut(&mut self) -> &mut Self::Target {
10732 &mut self.0
10733 }
10734}
10735#[doc(alias = "VkDescriptorImageInfo")]
10737#[derive(Copy, Clone, Hash, PartialEq, Eq)]
10738#[repr(C)]
10739pub struct DescriptorImageInfo {
10740 pub sampler: crate::vk1_0::Sampler,
10741 pub image_view: crate::vk1_0::ImageView,
10742 pub image_layout: crate::vk1_0::ImageLayout,
10743}
10744impl Default for DescriptorImageInfo {
10745 fn default() -> Self {
10746 Self {
10747 sampler: Default::default(),
10748 image_view: Default::default(),
10749 image_layout: Default::default(),
10750 }
10751 }
10752}
10753impl std::fmt::Debug for DescriptorImageInfo {
10754 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10755 f.debug_struct("DescriptorImageInfo")
10756 .field("sampler", &self.sampler)
10757 .field("image_view", &self.image_view)
10758 .field("image_layout", &self.image_layout)
10759 .finish()
10760 }
10761}
10762impl DescriptorImageInfo {
10763 #[inline]
10764 pub fn into_builder<'a>(self) -> DescriptorImageInfoBuilder<'a> {
10765 DescriptorImageInfoBuilder(self, std::marker::PhantomData)
10766 }
10767}
10768#[derive(Copy, Clone)]
10769#[repr(transparent)]
10771pub struct DescriptorImageInfoBuilder<'a>(
10772 DescriptorImageInfo,
10773 std::marker::PhantomData<&'a ()>,
10774);
10775impl<'a> DescriptorImageInfoBuilder<'a> {
10776 #[inline]
10777 pub fn new() -> DescriptorImageInfoBuilder<'a> {
10778 DescriptorImageInfoBuilder(Default::default(), std::marker::PhantomData)
10779 }
10780 #[inline]
10781 #[must_use]
10782 pub fn sampler(mut self, sampler: crate::vk1_0::Sampler) -> Self {
10783 self.0.sampler = sampler as _;
10784 self
10785 }
10786 #[inline]
10787 #[must_use]
10788 pub fn image_view(mut self, image_view: crate::vk1_0::ImageView) -> Self {
10789 self.0.image_view = image_view as _;
10790 self
10791 }
10792 #[inline]
10793 #[must_use]
10794 pub fn image_layout(mut self, image_layout: crate::vk1_0::ImageLayout) -> Self {
10795 self.0.image_layout = image_layout as _;
10796 self
10797 }
10798 #[inline]
10799 pub fn build(self) -> DescriptorImageInfo {
10800 self.0
10801 }
10802}
10803impl<'a> std::default::Default for DescriptorImageInfoBuilder<'a> {
10804 fn default() -> DescriptorImageInfoBuilder<'a> {
10805 Self::new()
10806 }
10807}
10808impl<'a> std::fmt::Debug for DescriptorImageInfoBuilder<'a> {
10809 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10810 std::fmt::Debug::fmt(&self.0, f)
10811 }
10812}
10813impl<'a> std::ops::Deref for DescriptorImageInfoBuilder<'a> {
10814 type Target = DescriptorImageInfo;
10815 fn deref(&self) -> &Self::Target {
10816 &self.0
10817 }
10818}
10819impl<'a> std::ops::DerefMut for DescriptorImageInfoBuilder<'a> {
10820 fn deref_mut(&mut self) -> &mut Self::Target {
10821 &mut self.0
10822 }
10823}
10824#[doc(alias = "VkWriteDescriptorSet")]
10826#[derive(Copy, Clone)]
10827#[repr(C)]
10828pub struct WriteDescriptorSet {
10829 pub s_type: crate::vk1_0::StructureType,
10830 pub p_next: *const std::ffi::c_void,
10831 pub dst_set: crate::vk1_0::DescriptorSet,
10832 pub dst_binding: u32,
10833 pub dst_array_element: u32,
10834 pub descriptor_count: u32,
10835 pub descriptor_type: crate::vk1_0::DescriptorType,
10836 pub p_image_info: *const crate::vk1_0::DescriptorImageInfo,
10837 pub p_buffer_info: *const crate::vk1_0::DescriptorBufferInfo,
10838 pub p_texel_buffer_view: *const crate::vk1_0::BufferView,
10839}
10840impl WriteDescriptorSet {
10841 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::WRITE_DESCRIPTOR_SET;
10842}
10843impl Default for WriteDescriptorSet {
10844 fn default() -> Self {
10845 Self {
10846 s_type: Self::STRUCTURE_TYPE,
10847 p_next: std::ptr::null(),
10848 dst_set: Default::default(),
10849 dst_binding: Default::default(),
10850 dst_array_element: Default::default(),
10851 descriptor_count: Default::default(),
10852 descriptor_type: Default::default(),
10853 p_image_info: std::ptr::null(),
10854 p_buffer_info: std::ptr::null(),
10855 p_texel_buffer_view: std::ptr::null(),
10856 }
10857 }
10858}
10859impl std::fmt::Debug for WriteDescriptorSet {
10860 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10861 f.debug_struct("WriteDescriptorSet")
10862 .field("s_type", &self.s_type)
10863 .field("p_next", &self.p_next)
10864 .field("dst_set", &self.dst_set)
10865 .field("dst_binding", &self.dst_binding)
10866 .field("dst_array_element", &self.dst_array_element)
10867 .field("descriptor_count", &self.descriptor_count)
10868 .field("descriptor_type", &self.descriptor_type)
10869 .field("p_image_info", &self.p_image_info)
10870 .field("p_buffer_info", &self.p_buffer_info)
10871 .field("p_texel_buffer_view", &self.p_texel_buffer_view)
10872 .finish()
10873 }
10874}
10875impl WriteDescriptorSet {
10876 #[inline]
10877 pub fn into_builder<'a>(self) -> WriteDescriptorSetBuilder<'a> {
10878 WriteDescriptorSetBuilder(self, std::marker::PhantomData)
10879 }
10880}
10881#[derive(Copy, Clone)]
10882#[repr(transparent)]
10884pub struct WriteDescriptorSetBuilder<'a>(
10885 WriteDescriptorSet,
10886 std::marker::PhantomData<&'a ()>,
10887);
10888impl<'a> WriteDescriptorSetBuilder<'a> {
10889 #[inline]
10890 pub fn new() -> WriteDescriptorSetBuilder<'a> {
10891 WriteDescriptorSetBuilder(Default::default(), std::marker::PhantomData)
10892 }
10893 #[inline]
10894 #[must_use]
10895 pub fn dst_set(mut self, dst_set: crate::vk1_0::DescriptorSet) -> Self {
10896 self.0.dst_set = dst_set as _;
10897 self
10898 }
10899 #[inline]
10900 #[must_use]
10901 pub fn dst_binding(mut self, dst_binding: u32) -> Self {
10902 self.0.dst_binding = dst_binding as _;
10903 self
10904 }
10905 #[inline]
10906 #[must_use]
10907 pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
10908 self.0.dst_array_element = dst_array_element as _;
10909 self
10910 }
10911 #[inline]
10912 #[must_use]
10913 pub fn descriptor_type(
10914 mut self,
10915 descriptor_type: crate::vk1_0::DescriptorType,
10916 ) -> Self {
10917 self.0.descriptor_type = descriptor_type as _;
10918 self
10919 }
10920 #[inline]
10921 #[must_use]
10922 pub fn image_info(
10923 mut self,
10924 image_info: &'a [crate::vk1_0::DescriptorImageInfoBuilder],
10925 ) -> Self {
10926 self.0.p_image_info = image_info.as_ptr() as _;
10927 self.0.descriptor_count = image_info.len() as _;
10928 self
10929 }
10930 #[inline]
10931 #[must_use]
10932 pub fn buffer_info(
10933 mut self,
10934 buffer_info: &'a [crate::vk1_0::DescriptorBufferInfoBuilder],
10935 ) -> Self {
10936 self.0.p_buffer_info = buffer_info.as_ptr() as _;
10937 self.0.descriptor_count = buffer_info.len() as _;
10938 self
10939 }
10940 #[inline]
10941 #[must_use]
10942 pub fn texel_buffer_view(
10943 mut self,
10944 texel_buffer_view: &'a [crate::vk1_0::BufferView],
10945 ) -> Self {
10946 self.0.p_texel_buffer_view = texel_buffer_view.as_ptr() as _;
10947 self.0.descriptor_count = texel_buffer_view.len() as _;
10948 self
10949 }
10950 #[inline]
10951 pub fn build_dangling(self) -> WriteDescriptorSet {
10954 self.0
10955 }
10956}
10957impl<'a> std::default::Default for WriteDescriptorSetBuilder<'a> {
10958 fn default() -> WriteDescriptorSetBuilder<'a> {
10959 Self::new()
10960 }
10961}
10962impl<'a> std::fmt::Debug for WriteDescriptorSetBuilder<'a> {
10963 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10964 std::fmt::Debug::fmt(&self.0, f)
10965 }
10966}
10967impl<'a> std::ops::Deref for WriteDescriptorSetBuilder<'a> {
10968 type Target = WriteDescriptorSet;
10969 fn deref(&self) -> &Self::Target {
10970 &self.0
10971 }
10972}
10973impl<'a> std::ops::DerefMut for WriteDescriptorSetBuilder<'a> {
10974 fn deref_mut(&mut self) -> &mut Self::Target {
10975 &mut self.0
10976 }
10977}
10978#[doc(alias = "VkCopyDescriptorSet")]
10980#[derive(Copy, Clone)]
10981#[repr(C)]
10982pub struct CopyDescriptorSet {
10983 pub s_type: crate::vk1_0::StructureType,
10984 pub p_next: *const std::ffi::c_void,
10985 pub src_set: crate::vk1_0::DescriptorSet,
10986 pub src_binding: u32,
10987 pub src_array_element: u32,
10988 pub dst_set: crate::vk1_0::DescriptorSet,
10989 pub dst_binding: u32,
10990 pub dst_array_element: u32,
10991 pub descriptor_count: u32,
10992}
10993impl CopyDescriptorSet {
10994 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::COPY_DESCRIPTOR_SET;
10995}
10996impl Default for CopyDescriptorSet {
10997 fn default() -> Self {
10998 Self {
10999 s_type: Self::STRUCTURE_TYPE,
11000 p_next: std::ptr::null(),
11001 src_set: Default::default(),
11002 src_binding: Default::default(),
11003 src_array_element: Default::default(),
11004 dst_set: Default::default(),
11005 dst_binding: Default::default(),
11006 dst_array_element: Default::default(),
11007 descriptor_count: Default::default(),
11008 }
11009 }
11010}
11011impl std::fmt::Debug for CopyDescriptorSet {
11012 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11013 f.debug_struct("CopyDescriptorSet")
11014 .field("s_type", &self.s_type)
11015 .field("p_next", &self.p_next)
11016 .field("src_set", &self.src_set)
11017 .field("src_binding", &self.src_binding)
11018 .field("src_array_element", &self.src_array_element)
11019 .field("dst_set", &self.dst_set)
11020 .field("dst_binding", &self.dst_binding)
11021 .field("dst_array_element", &self.dst_array_element)
11022 .field("descriptor_count", &self.descriptor_count)
11023 .finish()
11024 }
11025}
11026impl CopyDescriptorSet {
11027 #[inline]
11028 pub fn into_builder<'a>(self) -> CopyDescriptorSetBuilder<'a> {
11029 CopyDescriptorSetBuilder(self, std::marker::PhantomData)
11030 }
11031}
11032#[derive(Copy, Clone)]
11033#[repr(transparent)]
11035pub struct CopyDescriptorSetBuilder<'a>(
11036 CopyDescriptorSet,
11037 std::marker::PhantomData<&'a ()>,
11038);
11039impl<'a> CopyDescriptorSetBuilder<'a> {
11040 #[inline]
11041 pub fn new() -> CopyDescriptorSetBuilder<'a> {
11042 CopyDescriptorSetBuilder(Default::default(), std::marker::PhantomData)
11043 }
11044 #[inline]
11045 #[must_use]
11046 pub fn src_set(mut self, src_set: crate::vk1_0::DescriptorSet) -> Self {
11047 self.0.src_set = src_set as _;
11048 self
11049 }
11050 #[inline]
11051 #[must_use]
11052 pub fn src_binding(mut self, src_binding: u32) -> Self {
11053 self.0.src_binding = src_binding as _;
11054 self
11055 }
11056 #[inline]
11057 #[must_use]
11058 pub fn src_array_element(mut self, src_array_element: u32) -> Self {
11059 self.0.src_array_element = src_array_element as _;
11060 self
11061 }
11062 #[inline]
11063 #[must_use]
11064 pub fn dst_set(mut self, dst_set: crate::vk1_0::DescriptorSet) -> Self {
11065 self.0.dst_set = dst_set as _;
11066 self
11067 }
11068 #[inline]
11069 #[must_use]
11070 pub fn dst_binding(mut self, dst_binding: u32) -> Self {
11071 self.0.dst_binding = dst_binding as _;
11072 self
11073 }
11074 #[inline]
11075 #[must_use]
11076 pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
11077 self.0.dst_array_element = dst_array_element as _;
11078 self
11079 }
11080 #[inline]
11081 #[must_use]
11082 pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
11083 self.0.descriptor_count = descriptor_count as _;
11084 self
11085 }
11086 #[inline]
11087 pub fn build_dangling(self) -> CopyDescriptorSet {
11090 self.0
11091 }
11092}
11093impl<'a> std::default::Default for CopyDescriptorSetBuilder<'a> {
11094 fn default() -> CopyDescriptorSetBuilder<'a> {
11095 Self::new()
11096 }
11097}
11098impl<'a> std::fmt::Debug for CopyDescriptorSetBuilder<'a> {
11099 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11100 std::fmt::Debug::fmt(&self.0, f)
11101 }
11102}
11103impl<'a> std::ops::Deref for CopyDescriptorSetBuilder<'a> {
11104 type Target = CopyDescriptorSet;
11105 fn deref(&self) -> &Self::Target {
11106 &self.0
11107 }
11108}
11109impl<'a> std::ops::DerefMut for CopyDescriptorSetBuilder<'a> {
11110 fn deref_mut(&mut self) -> &mut Self::Target {
11111 &mut self.0
11112 }
11113}
11114#[doc(alias = "VkBufferCreateInfo")]
11116#[derive(Copy, Clone)]
11117#[repr(C)]
11118pub struct BufferCreateInfo {
11119 pub s_type: crate::vk1_0::StructureType,
11120 pub p_next: *const std::ffi::c_void,
11121 pub flags: crate::vk1_0::BufferCreateFlags,
11122 pub size: crate::vk1_0::DeviceSize,
11123 pub usage: crate::vk1_0::BufferUsageFlags,
11124 pub sharing_mode: crate::vk1_0::SharingMode,
11125 pub queue_family_index_count: u32,
11126 pub p_queue_family_indices: *const u32,
11127}
11128impl BufferCreateInfo {
11129 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::BUFFER_CREATE_INFO;
11130}
11131impl Default for BufferCreateInfo {
11132 fn default() -> Self {
11133 Self {
11134 s_type: Self::STRUCTURE_TYPE,
11135 p_next: std::ptr::null(),
11136 flags: Default::default(),
11137 size: Default::default(),
11138 usage: Default::default(),
11139 sharing_mode: Default::default(),
11140 queue_family_index_count: Default::default(),
11141 p_queue_family_indices: std::ptr::null(),
11142 }
11143 }
11144}
11145impl std::fmt::Debug for BufferCreateInfo {
11146 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11147 f.debug_struct("BufferCreateInfo")
11148 .field("s_type", &self.s_type)
11149 .field("p_next", &self.p_next)
11150 .field("flags", &self.flags)
11151 .field("size", &self.size)
11152 .field("usage", &self.usage)
11153 .field("sharing_mode", &self.sharing_mode)
11154 .field("queue_family_index_count", &self.queue_family_index_count)
11155 .field("p_queue_family_indices", &self.p_queue_family_indices)
11156 .finish()
11157 }
11158}
11159impl BufferCreateInfo {
11160 #[inline]
11161 pub fn into_builder<'a>(self) -> BufferCreateInfoBuilder<'a> {
11162 BufferCreateInfoBuilder(self, std::marker::PhantomData)
11163 }
11164}
11165#[derive(Copy, Clone)]
11166#[repr(transparent)]
11168pub struct BufferCreateInfoBuilder<'a>(
11169 BufferCreateInfo,
11170 std::marker::PhantomData<&'a ()>,
11171);
11172impl<'a> BufferCreateInfoBuilder<'a> {
11173 #[inline]
11174 pub fn new() -> BufferCreateInfoBuilder<'a> {
11175 BufferCreateInfoBuilder(Default::default(), std::marker::PhantomData)
11176 }
11177 #[inline]
11178 #[must_use]
11179 pub fn flags(mut self, flags: crate::vk1_0::BufferCreateFlags) -> Self {
11180 self.0.flags = flags as _;
11181 self
11182 }
11183 #[inline]
11184 #[must_use]
11185 pub fn size(mut self, size: crate::vk1_0::DeviceSize) -> Self {
11186 self.0.size = size as _;
11187 self
11188 }
11189 #[inline]
11190 #[must_use]
11191 pub fn usage(mut self, usage: crate::vk1_0::BufferUsageFlags) -> Self {
11192 self.0.usage = usage as _;
11193 self
11194 }
11195 #[inline]
11196 #[must_use]
11197 pub fn sharing_mode(mut self, sharing_mode: crate::vk1_0::SharingMode) -> Self {
11198 self.0.sharing_mode = sharing_mode as _;
11199 self
11200 }
11201 #[inline]
11202 #[must_use]
11203 pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
11204 self.0.p_queue_family_indices = queue_family_indices.as_ptr() as _;
11205 self.0.queue_family_index_count = queue_family_indices.len() as _;
11206 self
11207 }
11208 #[inline]
11209 pub fn build_dangling(self) -> BufferCreateInfo {
11212 self.0
11213 }
11214}
11215impl<'a> std::default::Default for BufferCreateInfoBuilder<'a> {
11216 fn default() -> BufferCreateInfoBuilder<'a> {
11217 Self::new()
11218 }
11219}
11220impl<'a> std::fmt::Debug for BufferCreateInfoBuilder<'a> {
11221 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11222 std::fmt::Debug::fmt(&self.0, f)
11223 }
11224}
11225impl<'a> std::ops::Deref for BufferCreateInfoBuilder<'a> {
11226 type Target = BufferCreateInfo;
11227 fn deref(&self) -> &Self::Target {
11228 &self.0
11229 }
11230}
11231impl<'a> std::ops::DerefMut for BufferCreateInfoBuilder<'a> {
11232 fn deref_mut(&mut self) -> &mut Self::Target {
11233 &mut self.0
11234 }
11235}
11236#[doc(alias = "VkBufferViewCreateInfo")]
11238#[derive(Copy, Clone)]
11239#[repr(C)]
11240pub struct BufferViewCreateInfo {
11241 pub s_type: crate::vk1_0::StructureType,
11242 pub p_next: *const std::ffi::c_void,
11243 pub flags: crate::vk1_0::BufferViewCreateFlags,
11244 pub buffer: crate::vk1_0::Buffer,
11245 pub format: crate::vk1_0::Format,
11246 pub offset: crate::vk1_0::DeviceSize,
11247 pub range: crate::vk1_0::DeviceSize,
11248}
11249impl BufferViewCreateInfo {
11250 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::BUFFER_VIEW_CREATE_INFO;
11251}
11252impl Default for BufferViewCreateInfo {
11253 fn default() -> Self {
11254 Self {
11255 s_type: Self::STRUCTURE_TYPE,
11256 p_next: std::ptr::null(),
11257 flags: Default::default(),
11258 buffer: Default::default(),
11259 format: Default::default(),
11260 offset: Default::default(),
11261 range: Default::default(),
11262 }
11263 }
11264}
11265impl std::fmt::Debug for BufferViewCreateInfo {
11266 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11267 f.debug_struct("BufferViewCreateInfo")
11268 .field("s_type", &self.s_type)
11269 .field("p_next", &self.p_next)
11270 .field("flags", &self.flags)
11271 .field("buffer", &self.buffer)
11272 .field("format", &self.format)
11273 .field("offset", &self.offset)
11274 .field("range", &self.range)
11275 .finish()
11276 }
11277}
11278impl BufferViewCreateInfo {
11279 #[inline]
11280 pub fn into_builder<'a>(self) -> BufferViewCreateInfoBuilder<'a> {
11281 BufferViewCreateInfoBuilder(self, std::marker::PhantomData)
11282 }
11283}
11284#[derive(Copy, Clone)]
11285#[repr(transparent)]
11287pub struct BufferViewCreateInfoBuilder<'a>(
11288 BufferViewCreateInfo,
11289 std::marker::PhantomData<&'a ()>,
11290);
11291impl<'a> BufferViewCreateInfoBuilder<'a> {
11292 #[inline]
11293 pub fn new() -> BufferViewCreateInfoBuilder<'a> {
11294 BufferViewCreateInfoBuilder(Default::default(), std::marker::PhantomData)
11295 }
11296 #[inline]
11297 #[must_use]
11298 pub fn flags(mut self, flags: crate::vk1_0::BufferViewCreateFlags) -> Self {
11299 self.0.flags = flags as _;
11300 self
11301 }
11302 #[inline]
11303 #[must_use]
11304 pub fn buffer(mut self, buffer: crate::vk1_0::Buffer) -> Self {
11305 self.0.buffer = buffer as _;
11306 self
11307 }
11308 #[inline]
11309 #[must_use]
11310 pub fn format(mut self, format: crate::vk1_0::Format) -> Self {
11311 self.0.format = format as _;
11312 self
11313 }
11314 #[inline]
11315 #[must_use]
11316 pub fn offset(mut self, offset: crate::vk1_0::DeviceSize) -> Self {
11317 self.0.offset = offset as _;
11318 self
11319 }
11320 #[inline]
11321 #[must_use]
11322 pub fn range(mut self, range: crate::vk1_0::DeviceSize) -> Self {
11323 self.0.range = range as _;
11324 self
11325 }
11326 #[inline]
11327 pub fn build_dangling(self) -> BufferViewCreateInfo {
11330 self.0
11331 }
11332}
11333impl<'a> std::default::Default for BufferViewCreateInfoBuilder<'a> {
11334 fn default() -> BufferViewCreateInfoBuilder<'a> {
11335 Self::new()
11336 }
11337}
11338impl<'a> std::fmt::Debug for BufferViewCreateInfoBuilder<'a> {
11339 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11340 std::fmt::Debug::fmt(&self.0, f)
11341 }
11342}
11343impl<'a> std::ops::Deref for BufferViewCreateInfoBuilder<'a> {
11344 type Target = BufferViewCreateInfo;
11345 fn deref(&self) -> &Self::Target {
11346 &self.0
11347 }
11348}
11349impl<'a> std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> {
11350 fn deref_mut(&mut self) -> &mut Self::Target {
11351 &mut self.0
11352 }
11353}
11354#[doc(alias = "VkImageSubresource")]
11356#[derive(Copy, Clone, Hash, PartialEq, Eq)]
11357#[repr(C)]
11358pub struct ImageSubresource {
11359 pub aspect_mask: crate::vk1_0::ImageAspectFlags,
11360 pub mip_level: u32,
11361 pub array_layer: u32,
11362}
11363impl Default for ImageSubresource {
11364 fn default() -> Self {
11365 Self {
11366 aspect_mask: Default::default(),
11367 mip_level: Default::default(),
11368 array_layer: Default::default(),
11369 }
11370 }
11371}
11372impl std::fmt::Debug for ImageSubresource {
11373 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11374 f.debug_struct("ImageSubresource")
11375 .field("aspect_mask", &self.aspect_mask)
11376 .field("mip_level", &self.mip_level)
11377 .field("array_layer", &self.array_layer)
11378 .finish()
11379 }
11380}
11381impl ImageSubresource {
11382 #[inline]
11383 pub fn into_builder<'a>(self) -> ImageSubresourceBuilder<'a> {
11384 ImageSubresourceBuilder(self, std::marker::PhantomData)
11385 }
11386}
11387#[derive(Copy, Clone)]
11388#[repr(transparent)]
11390pub struct ImageSubresourceBuilder<'a>(
11391 ImageSubresource,
11392 std::marker::PhantomData<&'a ()>,
11393);
11394impl<'a> ImageSubresourceBuilder<'a> {
11395 #[inline]
11396 pub fn new() -> ImageSubresourceBuilder<'a> {
11397 ImageSubresourceBuilder(Default::default(), std::marker::PhantomData)
11398 }
11399 #[inline]
11400 #[must_use]
11401 pub fn aspect_mask(mut self, aspect_mask: crate::vk1_0::ImageAspectFlags) -> Self {
11402 self.0.aspect_mask = aspect_mask as _;
11403 self
11404 }
11405 #[inline]
11406 #[must_use]
11407 pub fn mip_level(mut self, mip_level: u32) -> Self {
11408 self.0.mip_level = mip_level as _;
11409 self
11410 }
11411 #[inline]
11412 #[must_use]
11413 pub fn array_layer(mut self, array_layer: u32) -> Self {
11414 self.0.array_layer = array_layer as _;
11415 self
11416 }
11417 #[inline]
11418 pub fn build(self) -> ImageSubresource {
11419 self.0
11420 }
11421}
11422impl<'a> std::default::Default for ImageSubresourceBuilder<'a> {
11423 fn default() -> ImageSubresourceBuilder<'a> {
11424 Self::new()
11425 }
11426}
11427impl<'a> std::fmt::Debug for ImageSubresourceBuilder<'a> {
11428 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11429 std::fmt::Debug::fmt(&self.0, f)
11430 }
11431}
11432impl<'a> std::ops::Deref for ImageSubresourceBuilder<'a> {
11433 type Target = ImageSubresource;
11434 fn deref(&self) -> &Self::Target {
11435 &self.0
11436 }
11437}
11438impl<'a> std::ops::DerefMut for ImageSubresourceBuilder<'a> {
11439 fn deref_mut(&mut self) -> &mut Self::Target {
11440 &mut self.0
11441 }
11442}
11443#[doc(alias = "VkImageSubresourceLayers")]
11445#[derive(Copy, Clone, Hash, PartialEq, Eq)]
11446#[repr(C)]
11447pub struct ImageSubresourceLayers {
11448 pub aspect_mask: crate::vk1_0::ImageAspectFlags,
11449 pub mip_level: u32,
11450 pub base_array_layer: u32,
11451 pub layer_count: u32,
11452}
11453impl Default for ImageSubresourceLayers {
11454 fn default() -> Self {
11455 Self {
11456 aspect_mask: Default::default(),
11457 mip_level: Default::default(),
11458 base_array_layer: Default::default(),
11459 layer_count: Default::default(),
11460 }
11461 }
11462}
11463impl std::fmt::Debug for ImageSubresourceLayers {
11464 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11465 f.debug_struct("ImageSubresourceLayers")
11466 .field("aspect_mask", &self.aspect_mask)
11467 .field("mip_level", &self.mip_level)
11468 .field("base_array_layer", &self.base_array_layer)
11469 .field("layer_count", &self.layer_count)
11470 .finish()
11471 }
11472}
11473impl ImageSubresourceLayers {
11474 #[inline]
11475 pub fn into_builder<'a>(self) -> ImageSubresourceLayersBuilder<'a> {
11476 ImageSubresourceLayersBuilder(self, std::marker::PhantomData)
11477 }
11478}
11479#[derive(Copy, Clone)]
11480#[repr(transparent)]
11482pub struct ImageSubresourceLayersBuilder<'a>(
11483 ImageSubresourceLayers,
11484 std::marker::PhantomData<&'a ()>,
11485);
11486impl<'a> ImageSubresourceLayersBuilder<'a> {
11487 #[inline]
11488 pub fn new() -> ImageSubresourceLayersBuilder<'a> {
11489 ImageSubresourceLayersBuilder(Default::default(), std::marker::PhantomData)
11490 }
11491 #[inline]
11492 #[must_use]
11493 pub fn aspect_mask(mut self, aspect_mask: crate::vk1_0::ImageAspectFlags) -> Self {
11494 self.0.aspect_mask = aspect_mask as _;
11495 self
11496 }
11497 #[inline]
11498 #[must_use]
11499 pub fn mip_level(mut self, mip_level: u32) -> Self {
11500 self.0.mip_level = mip_level as _;
11501 self
11502 }
11503 #[inline]
11504 #[must_use]
11505 pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
11506 self.0.base_array_layer = base_array_layer as _;
11507 self
11508 }
11509 #[inline]
11510 #[must_use]
11511 pub fn layer_count(mut self, layer_count: u32) -> Self {
11512 self.0.layer_count = layer_count as _;
11513 self
11514 }
11515 #[inline]
11516 pub fn build(self) -> ImageSubresourceLayers {
11517 self.0
11518 }
11519}
11520impl<'a> std::default::Default for ImageSubresourceLayersBuilder<'a> {
11521 fn default() -> ImageSubresourceLayersBuilder<'a> {
11522 Self::new()
11523 }
11524}
11525impl<'a> std::fmt::Debug for ImageSubresourceLayersBuilder<'a> {
11526 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11527 std::fmt::Debug::fmt(&self.0, f)
11528 }
11529}
11530impl<'a> std::ops::Deref for ImageSubresourceLayersBuilder<'a> {
11531 type Target = ImageSubresourceLayers;
11532 fn deref(&self) -> &Self::Target {
11533 &self.0
11534 }
11535}
11536impl<'a> std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> {
11537 fn deref_mut(&mut self) -> &mut Self::Target {
11538 &mut self.0
11539 }
11540}
11541#[doc(alias = "VkImageSubresourceRange")]
11543#[derive(Copy, Clone, Hash, PartialEq, Eq)]
11544#[repr(C)]
11545pub struct ImageSubresourceRange {
11546 pub aspect_mask: crate::vk1_0::ImageAspectFlags,
11547 pub base_mip_level: u32,
11548 pub level_count: u32,
11549 pub base_array_layer: u32,
11550 pub layer_count: u32,
11551}
11552impl Default for ImageSubresourceRange {
11553 fn default() -> Self {
11554 Self {
11555 aspect_mask: Default::default(),
11556 base_mip_level: Default::default(),
11557 level_count: Default::default(),
11558 base_array_layer: Default::default(),
11559 layer_count: Default::default(),
11560 }
11561 }
11562}
11563impl std::fmt::Debug for ImageSubresourceRange {
11564 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11565 f.debug_struct("ImageSubresourceRange")
11566 .field("aspect_mask", &self.aspect_mask)
11567 .field("base_mip_level", &self.base_mip_level)
11568 .field("level_count", &self.level_count)
11569 .field("base_array_layer", &self.base_array_layer)
11570 .field("layer_count", &self.layer_count)
11571 .finish()
11572 }
11573}
11574impl ImageSubresourceRange {
11575 #[inline]
11576 pub fn into_builder<'a>(self) -> ImageSubresourceRangeBuilder<'a> {
11577 ImageSubresourceRangeBuilder(self, std::marker::PhantomData)
11578 }
11579}
11580#[derive(Copy, Clone)]
11581#[repr(transparent)]
11583pub struct ImageSubresourceRangeBuilder<'a>(
11584 ImageSubresourceRange,
11585 std::marker::PhantomData<&'a ()>,
11586);
11587impl<'a> ImageSubresourceRangeBuilder<'a> {
11588 #[inline]
11589 pub fn new() -> ImageSubresourceRangeBuilder<'a> {
11590 ImageSubresourceRangeBuilder(Default::default(), std::marker::PhantomData)
11591 }
11592 #[inline]
11593 #[must_use]
11594 pub fn aspect_mask(mut self, aspect_mask: crate::vk1_0::ImageAspectFlags) -> Self {
11595 self.0.aspect_mask = aspect_mask as _;
11596 self
11597 }
11598 #[inline]
11599 #[must_use]
11600 pub fn base_mip_level(mut self, base_mip_level: u32) -> Self {
11601 self.0.base_mip_level = base_mip_level as _;
11602 self
11603 }
11604 #[inline]
11605 #[must_use]
11606 pub fn level_count(mut self, level_count: u32) -> Self {
11607 self.0.level_count = level_count as _;
11608 self
11609 }
11610 #[inline]
11611 #[must_use]
11612 pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
11613 self.0.base_array_layer = base_array_layer as _;
11614 self
11615 }
11616 #[inline]
11617 #[must_use]
11618 pub fn layer_count(mut self, layer_count: u32) -> Self {
11619 self.0.layer_count = layer_count as _;
11620 self
11621 }
11622 #[inline]
11623 pub fn build(self) -> ImageSubresourceRange {
11624 self.0
11625 }
11626}
11627impl<'a> std::default::Default for ImageSubresourceRangeBuilder<'a> {
11628 fn default() -> ImageSubresourceRangeBuilder<'a> {
11629 Self::new()
11630 }
11631}
11632impl<'a> std::fmt::Debug for ImageSubresourceRangeBuilder<'a> {
11633 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11634 std::fmt::Debug::fmt(&self.0, f)
11635 }
11636}
11637impl<'a> std::ops::Deref for ImageSubresourceRangeBuilder<'a> {
11638 type Target = ImageSubresourceRange;
11639 fn deref(&self) -> &Self::Target {
11640 &self.0
11641 }
11642}
11643impl<'a> std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> {
11644 fn deref_mut(&mut self) -> &mut Self::Target {
11645 &mut self.0
11646 }
11647}
11648#[doc(alias = "VkMemoryBarrier")]
11650#[derive(Copy, Clone)]
11651#[repr(C)]
11652pub struct MemoryBarrier {
11653 pub s_type: crate::vk1_0::StructureType,
11654 pub p_next: *const std::ffi::c_void,
11655 pub src_access_mask: crate::vk1_0::AccessFlags,
11656 pub dst_access_mask: crate::vk1_0::AccessFlags,
11657}
11658impl MemoryBarrier {
11659 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::MEMORY_BARRIER;
11660}
11661impl Default for MemoryBarrier {
11662 fn default() -> Self {
11663 Self {
11664 s_type: Self::STRUCTURE_TYPE,
11665 p_next: std::ptr::null(),
11666 src_access_mask: Default::default(),
11667 dst_access_mask: Default::default(),
11668 }
11669 }
11670}
11671impl std::fmt::Debug for MemoryBarrier {
11672 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11673 f.debug_struct("MemoryBarrier")
11674 .field("s_type", &self.s_type)
11675 .field("p_next", &self.p_next)
11676 .field("src_access_mask", &self.src_access_mask)
11677 .field("dst_access_mask", &self.dst_access_mask)
11678 .finish()
11679 }
11680}
11681impl MemoryBarrier {
11682 #[inline]
11683 pub fn into_builder<'a>(self) -> MemoryBarrierBuilder<'a> {
11684 MemoryBarrierBuilder(self, std::marker::PhantomData)
11685 }
11686}
11687#[derive(Copy, Clone)]
11688#[repr(transparent)]
11690pub struct MemoryBarrierBuilder<'a>(MemoryBarrier, std::marker::PhantomData<&'a ()>);
11691impl<'a> MemoryBarrierBuilder<'a> {
11692 #[inline]
11693 pub fn new() -> MemoryBarrierBuilder<'a> {
11694 MemoryBarrierBuilder(Default::default(), std::marker::PhantomData)
11695 }
11696 #[inline]
11697 #[must_use]
11698 pub fn src_access_mask(
11699 mut self,
11700 src_access_mask: crate::vk1_0::AccessFlags,
11701 ) -> Self {
11702 self.0.src_access_mask = src_access_mask as _;
11703 self
11704 }
11705 #[inline]
11706 #[must_use]
11707 pub fn dst_access_mask(
11708 mut self,
11709 dst_access_mask: crate::vk1_0::AccessFlags,
11710 ) -> Self {
11711 self.0.dst_access_mask = dst_access_mask as _;
11712 self
11713 }
11714 #[inline]
11715 pub fn build_dangling(self) -> MemoryBarrier {
11718 self.0
11719 }
11720}
11721impl<'a> std::default::Default for MemoryBarrierBuilder<'a> {
11722 fn default() -> MemoryBarrierBuilder<'a> {
11723 Self::new()
11724 }
11725}
11726impl<'a> std::fmt::Debug for MemoryBarrierBuilder<'a> {
11727 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11728 std::fmt::Debug::fmt(&self.0, f)
11729 }
11730}
11731impl<'a> std::ops::Deref for MemoryBarrierBuilder<'a> {
11732 type Target = MemoryBarrier;
11733 fn deref(&self) -> &Self::Target {
11734 &self.0
11735 }
11736}
11737impl<'a> std::ops::DerefMut for MemoryBarrierBuilder<'a> {
11738 fn deref_mut(&mut self) -> &mut Self::Target {
11739 &mut self.0
11740 }
11741}
11742#[doc(alias = "VkBufferMemoryBarrier")]
11744#[derive(Copy, Clone)]
11745#[repr(C)]
11746pub struct BufferMemoryBarrier {
11747 pub s_type: crate::vk1_0::StructureType,
11748 pub p_next: *const std::ffi::c_void,
11749 pub src_access_mask: crate::vk1_0::AccessFlags,
11750 pub dst_access_mask: crate::vk1_0::AccessFlags,
11751 pub src_queue_family_index: u32,
11752 pub dst_queue_family_index: u32,
11753 pub buffer: crate::vk1_0::Buffer,
11754 pub offset: crate::vk1_0::DeviceSize,
11755 pub size: crate::vk1_0::DeviceSize,
11756}
11757impl BufferMemoryBarrier {
11758 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::BUFFER_MEMORY_BARRIER;
11759}
11760impl Default for BufferMemoryBarrier {
11761 fn default() -> Self {
11762 Self {
11763 s_type: Self::STRUCTURE_TYPE,
11764 p_next: std::ptr::null(),
11765 src_access_mask: Default::default(),
11766 dst_access_mask: Default::default(),
11767 src_queue_family_index: Default::default(),
11768 dst_queue_family_index: Default::default(),
11769 buffer: Default::default(),
11770 offset: Default::default(),
11771 size: Default::default(),
11772 }
11773 }
11774}
11775impl std::fmt::Debug for BufferMemoryBarrier {
11776 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11777 f.debug_struct("BufferMemoryBarrier")
11778 .field("s_type", &self.s_type)
11779 .field("p_next", &self.p_next)
11780 .field("src_access_mask", &self.src_access_mask)
11781 .field("dst_access_mask", &self.dst_access_mask)
11782 .field("src_queue_family_index", &self.src_queue_family_index)
11783 .field("dst_queue_family_index", &self.dst_queue_family_index)
11784 .field("buffer", &self.buffer)
11785 .field("offset", &self.offset)
11786 .field("size", &self.size)
11787 .finish()
11788 }
11789}
11790impl BufferMemoryBarrier {
11791 #[inline]
11792 pub fn into_builder<'a>(self) -> BufferMemoryBarrierBuilder<'a> {
11793 BufferMemoryBarrierBuilder(self, std::marker::PhantomData)
11794 }
11795}
11796#[derive(Copy, Clone)]
11797#[repr(transparent)]
11799pub struct BufferMemoryBarrierBuilder<'a>(
11800 BufferMemoryBarrier,
11801 std::marker::PhantomData<&'a ()>,
11802);
11803impl<'a> BufferMemoryBarrierBuilder<'a> {
11804 #[inline]
11805 pub fn new() -> BufferMemoryBarrierBuilder<'a> {
11806 BufferMemoryBarrierBuilder(Default::default(), std::marker::PhantomData)
11807 }
11808 #[inline]
11809 #[must_use]
11810 pub fn src_access_mask(
11811 mut self,
11812 src_access_mask: crate::vk1_0::AccessFlags,
11813 ) -> Self {
11814 self.0.src_access_mask = src_access_mask as _;
11815 self
11816 }
11817 #[inline]
11818 #[must_use]
11819 pub fn dst_access_mask(
11820 mut self,
11821 dst_access_mask: crate::vk1_0::AccessFlags,
11822 ) -> Self {
11823 self.0.dst_access_mask = dst_access_mask as _;
11824 self
11825 }
11826 #[inline]
11827 #[must_use]
11828 pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
11829 self.0.src_queue_family_index = src_queue_family_index as _;
11830 self
11831 }
11832 #[inline]
11833 #[must_use]
11834 pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
11835 self.0.dst_queue_family_index = dst_queue_family_index as _;
11836 self
11837 }
11838 #[inline]
11839 #[must_use]
11840 pub fn buffer(mut self, buffer: crate::vk1_0::Buffer) -> Self {
11841 self.0.buffer = buffer as _;
11842 self
11843 }
11844 #[inline]
11845 #[must_use]
11846 pub fn offset(mut self, offset: crate::vk1_0::DeviceSize) -> Self {
11847 self.0.offset = offset as _;
11848 self
11849 }
11850 #[inline]
11851 #[must_use]
11852 pub fn size(mut self, size: crate::vk1_0::DeviceSize) -> Self {
11853 self.0.size = size as _;
11854 self
11855 }
11856 #[inline]
11857 pub fn build_dangling(self) -> BufferMemoryBarrier {
11860 self.0
11861 }
11862}
11863impl<'a> std::default::Default for BufferMemoryBarrierBuilder<'a> {
11864 fn default() -> BufferMemoryBarrierBuilder<'a> {
11865 Self::new()
11866 }
11867}
11868impl<'a> std::fmt::Debug for BufferMemoryBarrierBuilder<'a> {
11869 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11870 std::fmt::Debug::fmt(&self.0, f)
11871 }
11872}
11873impl<'a> std::ops::Deref for BufferMemoryBarrierBuilder<'a> {
11874 type Target = BufferMemoryBarrier;
11875 fn deref(&self) -> &Self::Target {
11876 &self.0
11877 }
11878}
11879impl<'a> std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> {
11880 fn deref_mut(&mut self) -> &mut Self::Target {
11881 &mut self.0
11882 }
11883}
11884#[doc(alias = "VkImageMemoryBarrier")]
11886#[derive(Copy, Clone)]
11887#[repr(C)]
11888pub struct ImageMemoryBarrier {
11889 pub s_type: crate::vk1_0::StructureType,
11890 pub p_next: *const std::ffi::c_void,
11891 pub src_access_mask: crate::vk1_0::AccessFlags,
11892 pub dst_access_mask: crate::vk1_0::AccessFlags,
11893 pub old_layout: crate::vk1_0::ImageLayout,
11894 pub new_layout: crate::vk1_0::ImageLayout,
11895 pub src_queue_family_index: u32,
11896 pub dst_queue_family_index: u32,
11897 pub image: crate::vk1_0::Image,
11898 pub subresource_range: crate::vk1_0::ImageSubresourceRange,
11899}
11900impl ImageMemoryBarrier {
11901 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::IMAGE_MEMORY_BARRIER;
11902}
11903impl Default for ImageMemoryBarrier {
11904 fn default() -> Self {
11905 Self {
11906 s_type: Self::STRUCTURE_TYPE,
11907 p_next: std::ptr::null(),
11908 src_access_mask: Default::default(),
11909 dst_access_mask: Default::default(),
11910 old_layout: Default::default(),
11911 new_layout: Default::default(),
11912 src_queue_family_index: Default::default(),
11913 dst_queue_family_index: Default::default(),
11914 image: Default::default(),
11915 subresource_range: Default::default(),
11916 }
11917 }
11918}
11919impl std::fmt::Debug for ImageMemoryBarrier {
11920 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
11921 f.debug_struct("ImageMemoryBarrier")
11922 .field("s_type", &self.s_type)
11923 .field("p_next", &self.p_next)
11924 .field("src_access_mask", &self.src_access_mask)
11925 .field("dst_access_mask", &self.dst_access_mask)
11926 .field("old_layout", &self.old_layout)
11927 .field("new_layout", &self.new_layout)
11928 .field("src_queue_family_index", &self.src_queue_family_index)
11929 .field("dst_queue_family_index", &self.dst_queue_family_index)
11930 .field("image", &self.image)
11931 .field("subresource_range", &self.subresource_range)
11932 .finish()
11933 }
11934}
11935impl ImageMemoryBarrier {
11936 #[inline]
11937 pub fn into_builder<'a>(self) -> ImageMemoryBarrierBuilder<'a> {
11938 ImageMemoryBarrierBuilder(self, std::marker::PhantomData)
11939 }
11940}
11941#[derive(Copy, Clone)]
11942#[repr(transparent)]
11944pub struct ImageMemoryBarrierBuilder<'a>(
11945 ImageMemoryBarrier,
11946 std::marker::PhantomData<&'a ()>,
11947);
11948impl<'a> ImageMemoryBarrierBuilder<'a> {
11949 #[inline]
11950 pub fn new() -> ImageMemoryBarrierBuilder<'a> {
11951 ImageMemoryBarrierBuilder(Default::default(), std::marker::PhantomData)
11952 }
11953 #[inline]
11954 #[must_use]
11955 pub fn src_access_mask(
11956 mut self,
11957 src_access_mask: crate::vk1_0::AccessFlags,
11958 ) -> Self {
11959 self.0.src_access_mask = src_access_mask as _;
11960 self
11961 }
11962 #[inline]
11963 #[must_use]
11964 pub fn dst_access_mask(
11965 mut self,
11966 dst_access_mask: crate::vk1_0::AccessFlags,
11967 ) -> Self {
11968 self.0.dst_access_mask = dst_access_mask as _;
11969 self
11970 }
11971 #[inline]
11972 #[must_use]
11973 pub fn old_layout(mut self, old_layout: crate::vk1_0::ImageLayout) -> Self {
11974 self.0.old_layout = old_layout as _;
11975 self
11976 }
11977 #[inline]
11978 #[must_use]
11979 pub fn new_layout(mut self, new_layout: crate::vk1_0::ImageLayout) -> Self {
11980 self.0.new_layout = new_layout as _;
11981 self
11982 }
11983 #[inline]
11984 #[must_use]
11985 pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
11986 self.0.src_queue_family_index = src_queue_family_index as _;
11987 self
11988 }
11989 #[inline]
11990 #[must_use]
11991 pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
11992 self.0.dst_queue_family_index = dst_queue_family_index as _;
11993 self
11994 }
11995 #[inline]
11996 #[must_use]
11997 pub fn image(mut self, image: crate::vk1_0::Image) -> Self {
11998 self.0.image = image as _;
11999 self
12000 }
12001 #[inline]
12002 #[must_use]
12003 pub fn subresource_range(
12004 mut self,
12005 subresource_range: crate::vk1_0::ImageSubresourceRange,
12006 ) -> Self {
12007 self.0.subresource_range = subresource_range as _;
12008 self
12009 }
12010 #[inline]
12011 pub fn build_dangling(self) -> ImageMemoryBarrier {
12014 self.0
12015 }
12016}
12017impl<'a> std::default::Default for ImageMemoryBarrierBuilder<'a> {
12018 fn default() -> ImageMemoryBarrierBuilder<'a> {
12019 Self::new()
12020 }
12021}
12022impl<'a> std::fmt::Debug for ImageMemoryBarrierBuilder<'a> {
12023 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12024 std::fmt::Debug::fmt(&self.0, f)
12025 }
12026}
12027impl<'a> std::ops::Deref for ImageMemoryBarrierBuilder<'a> {
12028 type Target = ImageMemoryBarrier;
12029 fn deref(&self) -> &Self::Target {
12030 &self.0
12031 }
12032}
12033impl<'a> std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> {
12034 fn deref_mut(&mut self) -> &mut Self::Target {
12035 &mut self.0
12036 }
12037}
12038#[doc(alias = "VkImageCreateInfo")]
12040#[derive(Copy, Clone)]
12041#[repr(C)]
12042pub struct ImageCreateInfo {
12043 pub s_type: crate::vk1_0::StructureType,
12044 pub p_next: *const std::ffi::c_void,
12045 pub flags: crate::vk1_0::ImageCreateFlags,
12046 pub image_type: crate::vk1_0::ImageType,
12047 pub format: crate::vk1_0::Format,
12048 pub extent: crate::vk1_0::Extent3D,
12049 pub mip_levels: u32,
12050 pub array_layers: u32,
12051 pub samples: crate::vk1_0::SampleCountFlagBits,
12052 pub tiling: crate::vk1_0::ImageTiling,
12053 pub usage: crate::vk1_0::ImageUsageFlags,
12054 pub sharing_mode: crate::vk1_0::SharingMode,
12055 pub queue_family_index_count: u32,
12056 pub p_queue_family_indices: *const u32,
12057 pub initial_layout: crate::vk1_0::ImageLayout,
12058}
12059impl ImageCreateInfo {
12060 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::IMAGE_CREATE_INFO;
12061}
12062impl Default for ImageCreateInfo {
12063 fn default() -> Self {
12064 Self {
12065 s_type: Self::STRUCTURE_TYPE,
12066 p_next: std::ptr::null(),
12067 flags: Default::default(),
12068 image_type: Default::default(),
12069 format: Default::default(),
12070 extent: Default::default(),
12071 mip_levels: Default::default(),
12072 array_layers: Default::default(),
12073 samples: Default::default(),
12074 tiling: Default::default(),
12075 usage: Default::default(),
12076 sharing_mode: Default::default(),
12077 queue_family_index_count: Default::default(),
12078 p_queue_family_indices: std::ptr::null(),
12079 initial_layout: Default::default(),
12080 }
12081 }
12082}
12083impl std::fmt::Debug for ImageCreateInfo {
12084 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12085 f.debug_struct("ImageCreateInfo")
12086 .field("s_type", &self.s_type)
12087 .field("p_next", &self.p_next)
12088 .field("flags", &self.flags)
12089 .field("image_type", &self.image_type)
12090 .field("format", &self.format)
12091 .field("extent", &self.extent)
12092 .field("mip_levels", &self.mip_levels)
12093 .field("array_layers", &self.array_layers)
12094 .field("samples", &self.samples)
12095 .field("tiling", &self.tiling)
12096 .field("usage", &self.usage)
12097 .field("sharing_mode", &self.sharing_mode)
12098 .field("queue_family_index_count", &self.queue_family_index_count)
12099 .field("p_queue_family_indices", &self.p_queue_family_indices)
12100 .field("initial_layout", &self.initial_layout)
12101 .finish()
12102 }
12103}
12104impl ImageCreateInfo {
12105 #[inline]
12106 pub fn into_builder<'a>(self) -> ImageCreateInfoBuilder<'a> {
12107 ImageCreateInfoBuilder(self, std::marker::PhantomData)
12108 }
12109}
12110#[derive(Copy, Clone)]
12111#[repr(transparent)]
12113pub struct ImageCreateInfoBuilder<'a>(ImageCreateInfo, std::marker::PhantomData<&'a ()>);
12114impl<'a> ImageCreateInfoBuilder<'a> {
12115 #[inline]
12116 pub fn new() -> ImageCreateInfoBuilder<'a> {
12117 ImageCreateInfoBuilder(Default::default(), std::marker::PhantomData)
12118 }
12119 #[inline]
12120 #[must_use]
12121 pub fn flags(mut self, flags: crate::vk1_0::ImageCreateFlags) -> Self {
12122 self.0.flags = flags as _;
12123 self
12124 }
12125 #[inline]
12126 #[must_use]
12127 pub fn image_type(mut self, image_type: crate::vk1_0::ImageType) -> Self {
12128 self.0.image_type = image_type as _;
12129 self
12130 }
12131 #[inline]
12132 #[must_use]
12133 pub fn format(mut self, format: crate::vk1_0::Format) -> Self {
12134 self.0.format = format as _;
12135 self
12136 }
12137 #[inline]
12138 #[must_use]
12139 pub fn extent(mut self, extent: crate::vk1_0::Extent3D) -> Self {
12140 self.0.extent = extent as _;
12141 self
12142 }
12143 #[inline]
12144 #[must_use]
12145 pub fn mip_levels(mut self, mip_levels: u32) -> Self {
12146 self.0.mip_levels = mip_levels as _;
12147 self
12148 }
12149 #[inline]
12150 #[must_use]
12151 pub fn array_layers(mut self, array_layers: u32) -> Self {
12152 self.0.array_layers = array_layers as _;
12153 self
12154 }
12155 #[inline]
12156 #[must_use]
12157 pub fn samples(mut self, samples: crate::vk1_0::SampleCountFlagBits) -> Self {
12158 self.0.samples = samples as _;
12159 self
12160 }
12161 #[inline]
12162 #[must_use]
12163 pub fn tiling(mut self, tiling: crate::vk1_0::ImageTiling) -> Self {
12164 self.0.tiling = tiling as _;
12165 self
12166 }
12167 #[inline]
12168 #[must_use]
12169 pub fn usage(mut self, usage: crate::vk1_0::ImageUsageFlags) -> Self {
12170 self.0.usage = usage as _;
12171 self
12172 }
12173 #[inline]
12174 #[must_use]
12175 pub fn sharing_mode(mut self, sharing_mode: crate::vk1_0::SharingMode) -> Self {
12176 self.0.sharing_mode = sharing_mode as _;
12177 self
12178 }
12179 #[inline]
12180 #[must_use]
12181 pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
12182 self.0.p_queue_family_indices = queue_family_indices.as_ptr() as _;
12183 self.0.queue_family_index_count = queue_family_indices.len() as _;
12184 self
12185 }
12186 #[inline]
12187 #[must_use]
12188 pub fn initial_layout(mut self, initial_layout: crate::vk1_0::ImageLayout) -> Self {
12189 self.0.initial_layout = initial_layout as _;
12190 self
12191 }
12192 #[inline]
12193 pub fn build_dangling(self) -> ImageCreateInfo {
12196 self.0
12197 }
12198}
12199impl<'a> std::default::Default for ImageCreateInfoBuilder<'a> {
12200 fn default() -> ImageCreateInfoBuilder<'a> {
12201 Self::new()
12202 }
12203}
12204impl<'a> std::fmt::Debug for ImageCreateInfoBuilder<'a> {
12205 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12206 std::fmt::Debug::fmt(&self.0, f)
12207 }
12208}
12209impl<'a> std::ops::Deref for ImageCreateInfoBuilder<'a> {
12210 type Target = ImageCreateInfo;
12211 fn deref(&self) -> &Self::Target {
12212 &self.0
12213 }
12214}
12215impl<'a> std::ops::DerefMut for ImageCreateInfoBuilder<'a> {
12216 fn deref_mut(&mut self) -> &mut Self::Target {
12217 &mut self.0
12218 }
12219}
12220#[doc(alias = "VkSubresourceLayout")]
12222#[derive(Copy, Clone, Hash, PartialEq, Eq)]
12223#[repr(C)]
12224pub struct SubresourceLayout {
12225 pub offset: crate::vk1_0::DeviceSize,
12226 pub size: crate::vk1_0::DeviceSize,
12227 pub row_pitch: crate::vk1_0::DeviceSize,
12228 pub array_pitch: crate::vk1_0::DeviceSize,
12229 pub depth_pitch: crate::vk1_0::DeviceSize,
12230}
12231impl Default for SubresourceLayout {
12232 fn default() -> Self {
12233 Self {
12234 offset: Default::default(),
12235 size: Default::default(),
12236 row_pitch: Default::default(),
12237 array_pitch: Default::default(),
12238 depth_pitch: Default::default(),
12239 }
12240 }
12241}
12242impl std::fmt::Debug for SubresourceLayout {
12243 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12244 f.debug_struct("SubresourceLayout")
12245 .field("offset", &self.offset)
12246 .field("size", &self.size)
12247 .field("row_pitch", &self.row_pitch)
12248 .field("array_pitch", &self.array_pitch)
12249 .field("depth_pitch", &self.depth_pitch)
12250 .finish()
12251 }
12252}
12253impl SubresourceLayout {
12254 #[inline]
12255 pub fn into_builder<'a>(self) -> SubresourceLayoutBuilder<'a> {
12256 SubresourceLayoutBuilder(self, std::marker::PhantomData)
12257 }
12258}
12259#[derive(Copy, Clone)]
12260#[repr(transparent)]
12262pub struct SubresourceLayoutBuilder<'a>(
12263 SubresourceLayout,
12264 std::marker::PhantomData<&'a ()>,
12265);
12266impl<'a> SubresourceLayoutBuilder<'a> {
12267 #[inline]
12268 pub fn new() -> SubresourceLayoutBuilder<'a> {
12269 SubresourceLayoutBuilder(Default::default(), std::marker::PhantomData)
12270 }
12271 #[inline]
12272 #[must_use]
12273 pub fn offset(mut self, offset: crate::vk1_0::DeviceSize) -> Self {
12274 self.0.offset = offset as _;
12275 self
12276 }
12277 #[inline]
12278 #[must_use]
12279 pub fn size(mut self, size: crate::vk1_0::DeviceSize) -> Self {
12280 self.0.size = size as _;
12281 self
12282 }
12283 #[inline]
12284 #[must_use]
12285 pub fn row_pitch(mut self, row_pitch: crate::vk1_0::DeviceSize) -> Self {
12286 self.0.row_pitch = row_pitch as _;
12287 self
12288 }
12289 #[inline]
12290 #[must_use]
12291 pub fn array_pitch(mut self, array_pitch: crate::vk1_0::DeviceSize) -> Self {
12292 self.0.array_pitch = array_pitch as _;
12293 self
12294 }
12295 #[inline]
12296 #[must_use]
12297 pub fn depth_pitch(mut self, depth_pitch: crate::vk1_0::DeviceSize) -> Self {
12298 self.0.depth_pitch = depth_pitch as _;
12299 self
12300 }
12301 #[inline]
12302 pub fn build(self) -> SubresourceLayout {
12303 self.0
12304 }
12305}
12306impl<'a> std::default::Default for SubresourceLayoutBuilder<'a> {
12307 fn default() -> SubresourceLayoutBuilder<'a> {
12308 Self::new()
12309 }
12310}
12311impl<'a> std::fmt::Debug for SubresourceLayoutBuilder<'a> {
12312 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12313 std::fmt::Debug::fmt(&self.0, f)
12314 }
12315}
12316impl<'a> std::ops::Deref for SubresourceLayoutBuilder<'a> {
12317 type Target = SubresourceLayout;
12318 fn deref(&self) -> &Self::Target {
12319 &self.0
12320 }
12321}
12322impl<'a> std::ops::DerefMut for SubresourceLayoutBuilder<'a> {
12323 fn deref_mut(&mut self) -> &mut Self::Target {
12324 &mut self.0
12325 }
12326}
12327#[doc(alias = "VkImageViewCreateInfo")]
12329#[derive(Copy, Clone)]
12330#[repr(C)]
12331pub struct ImageViewCreateInfo {
12332 pub s_type: crate::vk1_0::StructureType,
12333 pub p_next: *const std::ffi::c_void,
12334 pub flags: crate::vk1_0::ImageViewCreateFlags,
12335 pub image: crate::vk1_0::Image,
12336 pub view_type: crate::vk1_0::ImageViewType,
12337 pub format: crate::vk1_0::Format,
12338 pub components: crate::vk1_0::ComponentMapping,
12339 pub subresource_range: crate::vk1_0::ImageSubresourceRange,
12340}
12341impl ImageViewCreateInfo {
12342 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::IMAGE_VIEW_CREATE_INFO;
12343}
12344impl Default for ImageViewCreateInfo {
12345 fn default() -> Self {
12346 Self {
12347 s_type: Self::STRUCTURE_TYPE,
12348 p_next: std::ptr::null(),
12349 flags: Default::default(),
12350 image: Default::default(),
12351 view_type: Default::default(),
12352 format: Default::default(),
12353 components: Default::default(),
12354 subresource_range: Default::default(),
12355 }
12356 }
12357}
12358impl std::fmt::Debug for ImageViewCreateInfo {
12359 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12360 f.debug_struct("ImageViewCreateInfo")
12361 .field("s_type", &self.s_type)
12362 .field("p_next", &self.p_next)
12363 .field("flags", &self.flags)
12364 .field("image", &self.image)
12365 .field("view_type", &self.view_type)
12366 .field("format", &self.format)
12367 .field("components", &self.components)
12368 .field("subresource_range", &self.subresource_range)
12369 .finish()
12370 }
12371}
12372impl ImageViewCreateInfo {
12373 #[inline]
12374 pub fn into_builder<'a>(self) -> ImageViewCreateInfoBuilder<'a> {
12375 ImageViewCreateInfoBuilder(self, std::marker::PhantomData)
12376 }
12377}
12378#[derive(Copy, Clone)]
12379#[repr(transparent)]
12381pub struct ImageViewCreateInfoBuilder<'a>(
12382 ImageViewCreateInfo,
12383 std::marker::PhantomData<&'a ()>,
12384);
12385impl<'a> ImageViewCreateInfoBuilder<'a> {
12386 #[inline]
12387 pub fn new() -> ImageViewCreateInfoBuilder<'a> {
12388 ImageViewCreateInfoBuilder(Default::default(), std::marker::PhantomData)
12389 }
12390 #[inline]
12391 #[must_use]
12392 pub fn flags(mut self, flags: crate::vk1_0::ImageViewCreateFlags) -> Self {
12393 self.0.flags = flags as _;
12394 self
12395 }
12396 #[inline]
12397 #[must_use]
12398 pub fn image(mut self, image: crate::vk1_0::Image) -> Self {
12399 self.0.image = image as _;
12400 self
12401 }
12402 #[inline]
12403 #[must_use]
12404 pub fn view_type(mut self, view_type: crate::vk1_0::ImageViewType) -> Self {
12405 self.0.view_type = view_type as _;
12406 self
12407 }
12408 #[inline]
12409 #[must_use]
12410 pub fn format(mut self, format: crate::vk1_0::Format) -> Self {
12411 self.0.format = format as _;
12412 self
12413 }
12414 #[inline]
12415 #[must_use]
12416 pub fn components(mut self, components: crate::vk1_0::ComponentMapping) -> Self {
12417 self.0.components = components as _;
12418 self
12419 }
12420 #[inline]
12421 #[must_use]
12422 pub fn subresource_range(
12423 mut self,
12424 subresource_range: crate::vk1_0::ImageSubresourceRange,
12425 ) -> Self {
12426 self.0.subresource_range = subresource_range as _;
12427 self
12428 }
12429 #[inline]
12430 pub fn build_dangling(self) -> ImageViewCreateInfo {
12433 self.0
12434 }
12435}
12436impl<'a> std::default::Default for ImageViewCreateInfoBuilder<'a> {
12437 fn default() -> ImageViewCreateInfoBuilder<'a> {
12438 Self::new()
12439 }
12440}
12441impl<'a> std::fmt::Debug for ImageViewCreateInfoBuilder<'a> {
12442 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12443 std::fmt::Debug::fmt(&self.0, f)
12444 }
12445}
12446impl<'a> std::ops::Deref for ImageViewCreateInfoBuilder<'a> {
12447 type Target = ImageViewCreateInfo;
12448 fn deref(&self) -> &Self::Target {
12449 &self.0
12450 }
12451}
12452impl<'a> std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> {
12453 fn deref_mut(&mut self) -> &mut Self::Target {
12454 &mut self.0
12455 }
12456}
12457#[doc(alias = "VkBufferCopy")]
12459#[derive(Copy, Clone, Hash, PartialEq, Eq)]
12460#[repr(C)]
12461pub struct BufferCopy {
12462 pub src_offset: crate::vk1_0::DeviceSize,
12463 pub dst_offset: crate::vk1_0::DeviceSize,
12464 pub size: crate::vk1_0::DeviceSize,
12465}
12466impl Default for BufferCopy {
12467 fn default() -> Self {
12468 Self {
12469 src_offset: Default::default(),
12470 dst_offset: Default::default(),
12471 size: Default::default(),
12472 }
12473 }
12474}
12475impl std::fmt::Debug for BufferCopy {
12476 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12477 f.debug_struct("BufferCopy")
12478 .field("src_offset", &self.src_offset)
12479 .field("dst_offset", &self.dst_offset)
12480 .field("size", &self.size)
12481 .finish()
12482 }
12483}
12484impl BufferCopy {
12485 #[inline]
12486 pub fn into_builder<'a>(self) -> BufferCopyBuilder<'a> {
12487 BufferCopyBuilder(self, std::marker::PhantomData)
12488 }
12489}
12490#[derive(Copy, Clone)]
12491#[repr(transparent)]
12493pub struct BufferCopyBuilder<'a>(BufferCopy, std::marker::PhantomData<&'a ()>);
12494impl<'a> BufferCopyBuilder<'a> {
12495 #[inline]
12496 pub fn new() -> BufferCopyBuilder<'a> {
12497 BufferCopyBuilder(Default::default(), std::marker::PhantomData)
12498 }
12499 #[inline]
12500 #[must_use]
12501 pub fn src_offset(mut self, src_offset: crate::vk1_0::DeviceSize) -> Self {
12502 self.0.src_offset = src_offset as _;
12503 self
12504 }
12505 #[inline]
12506 #[must_use]
12507 pub fn dst_offset(mut self, dst_offset: crate::vk1_0::DeviceSize) -> Self {
12508 self.0.dst_offset = dst_offset as _;
12509 self
12510 }
12511 #[inline]
12512 #[must_use]
12513 pub fn size(mut self, size: crate::vk1_0::DeviceSize) -> Self {
12514 self.0.size = size as _;
12515 self
12516 }
12517 #[inline]
12518 pub fn build(self) -> BufferCopy {
12519 self.0
12520 }
12521}
12522impl<'a> std::default::Default for BufferCopyBuilder<'a> {
12523 fn default() -> BufferCopyBuilder<'a> {
12524 Self::new()
12525 }
12526}
12527impl<'a> std::fmt::Debug for BufferCopyBuilder<'a> {
12528 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12529 std::fmt::Debug::fmt(&self.0, f)
12530 }
12531}
12532impl<'a> std::ops::Deref for BufferCopyBuilder<'a> {
12533 type Target = BufferCopy;
12534 fn deref(&self) -> &Self::Target {
12535 &self.0
12536 }
12537}
12538impl<'a> std::ops::DerefMut for BufferCopyBuilder<'a> {
12539 fn deref_mut(&mut self) -> &mut Self::Target {
12540 &mut self.0
12541 }
12542}
12543#[doc(alias = "VkSparseMemoryBind")]
12545#[derive(Copy, Clone, Hash, PartialEq, Eq)]
12546#[repr(C)]
12547pub struct SparseMemoryBind {
12548 pub resource_offset: crate::vk1_0::DeviceSize,
12549 pub size: crate::vk1_0::DeviceSize,
12550 pub memory: crate::vk1_0::DeviceMemory,
12551 pub memory_offset: crate::vk1_0::DeviceSize,
12552 pub flags: crate::vk1_0::SparseMemoryBindFlags,
12553}
12554impl Default for SparseMemoryBind {
12555 fn default() -> Self {
12556 Self {
12557 resource_offset: Default::default(),
12558 size: Default::default(),
12559 memory: Default::default(),
12560 memory_offset: Default::default(),
12561 flags: Default::default(),
12562 }
12563 }
12564}
12565impl std::fmt::Debug for SparseMemoryBind {
12566 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12567 f.debug_struct("SparseMemoryBind")
12568 .field("resource_offset", &self.resource_offset)
12569 .field("size", &self.size)
12570 .field("memory", &self.memory)
12571 .field("memory_offset", &self.memory_offset)
12572 .field("flags", &self.flags)
12573 .finish()
12574 }
12575}
12576impl SparseMemoryBind {
12577 #[inline]
12578 pub fn into_builder<'a>(self) -> SparseMemoryBindBuilder<'a> {
12579 SparseMemoryBindBuilder(self, std::marker::PhantomData)
12580 }
12581}
12582#[derive(Copy, Clone)]
12583#[repr(transparent)]
12585pub struct SparseMemoryBindBuilder<'a>(
12586 SparseMemoryBind,
12587 std::marker::PhantomData<&'a ()>,
12588);
12589impl<'a> SparseMemoryBindBuilder<'a> {
12590 #[inline]
12591 pub fn new() -> SparseMemoryBindBuilder<'a> {
12592 SparseMemoryBindBuilder(Default::default(), std::marker::PhantomData)
12593 }
12594 #[inline]
12595 #[must_use]
12596 pub fn resource_offset(mut self, resource_offset: crate::vk1_0::DeviceSize) -> Self {
12597 self.0.resource_offset = resource_offset as _;
12598 self
12599 }
12600 #[inline]
12601 #[must_use]
12602 pub fn size(mut self, size: crate::vk1_0::DeviceSize) -> Self {
12603 self.0.size = size as _;
12604 self
12605 }
12606 #[inline]
12607 #[must_use]
12608 pub fn memory(mut self, memory: crate::vk1_0::DeviceMemory) -> Self {
12609 self.0.memory = memory as _;
12610 self
12611 }
12612 #[inline]
12613 #[must_use]
12614 pub fn memory_offset(mut self, memory_offset: crate::vk1_0::DeviceSize) -> Self {
12615 self.0.memory_offset = memory_offset as _;
12616 self
12617 }
12618 #[inline]
12619 #[must_use]
12620 pub fn flags(mut self, flags: crate::vk1_0::SparseMemoryBindFlags) -> Self {
12621 self.0.flags = flags as _;
12622 self
12623 }
12624 #[inline]
12625 pub fn build(self) -> SparseMemoryBind {
12626 self.0
12627 }
12628}
12629impl<'a> std::default::Default for SparseMemoryBindBuilder<'a> {
12630 fn default() -> SparseMemoryBindBuilder<'a> {
12631 Self::new()
12632 }
12633}
12634impl<'a> std::fmt::Debug for SparseMemoryBindBuilder<'a> {
12635 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12636 std::fmt::Debug::fmt(&self.0, f)
12637 }
12638}
12639impl<'a> std::ops::Deref for SparseMemoryBindBuilder<'a> {
12640 type Target = SparseMemoryBind;
12641 fn deref(&self) -> &Self::Target {
12642 &self.0
12643 }
12644}
12645impl<'a> std::ops::DerefMut for SparseMemoryBindBuilder<'a> {
12646 fn deref_mut(&mut self) -> &mut Self::Target {
12647 &mut self.0
12648 }
12649}
12650#[doc(alias = "VkSparseImageMemoryBind")]
12652#[derive(Copy, Clone, Hash, PartialEq, Eq)]
12653#[repr(C)]
12654pub struct SparseImageMemoryBind {
12655 pub subresource: crate::vk1_0::ImageSubresource,
12656 pub offset: crate::vk1_0::Offset3D,
12657 pub extent: crate::vk1_0::Extent3D,
12658 pub memory: crate::vk1_0::DeviceMemory,
12659 pub memory_offset: crate::vk1_0::DeviceSize,
12660 pub flags: crate::vk1_0::SparseMemoryBindFlags,
12661}
12662impl Default for SparseImageMemoryBind {
12663 fn default() -> Self {
12664 Self {
12665 subresource: Default::default(),
12666 offset: Default::default(),
12667 extent: Default::default(),
12668 memory: Default::default(),
12669 memory_offset: Default::default(),
12670 flags: Default::default(),
12671 }
12672 }
12673}
12674impl std::fmt::Debug for SparseImageMemoryBind {
12675 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12676 f.debug_struct("SparseImageMemoryBind")
12677 .field("subresource", &self.subresource)
12678 .field("offset", &self.offset)
12679 .field("extent", &self.extent)
12680 .field("memory", &self.memory)
12681 .field("memory_offset", &self.memory_offset)
12682 .field("flags", &self.flags)
12683 .finish()
12684 }
12685}
12686impl SparseImageMemoryBind {
12687 #[inline]
12688 pub fn into_builder<'a>(self) -> SparseImageMemoryBindBuilder<'a> {
12689 SparseImageMemoryBindBuilder(self, std::marker::PhantomData)
12690 }
12691}
12692#[derive(Copy, Clone)]
12693#[repr(transparent)]
12695pub struct SparseImageMemoryBindBuilder<'a>(
12696 SparseImageMemoryBind,
12697 std::marker::PhantomData<&'a ()>,
12698);
12699impl<'a> SparseImageMemoryBindBuilder<'a> {
12700 #[inline]
12701 pub fn new() -> SparseImageMemoryBindBuilder<'a> {
12702 SparseImageMemoryBindBuilder(Default::default(), std::marker::PhantomData)
12703 }
12704 #[inline]
12705 #[must_use]
12706 pub fn subresource(mut self, subresource: crate::vk1_0::ImageSubresource) -> Self {
12707 self.0.subresource = subresource as _;
12708 self
12709 }
12710 #[inline]
12711 #[must_use]
12712 pub fn offset(mut self, offset: crate::vk1_0::Offset3D) -> Self {
12713 self.0.offset = offset as _;
12714 self
12715 }
12716 #[inline]
12717 #[must_use]
12718 pub fn extent(mut self, extent: crate::vk1_0::Extent3D) -> Self {
12719 self.0.extent = extent as _;
12720 self
12721 }
12722 #[inline]
12723 #[must_use]
12724 pub fn memory(mut self, memory: crate::vk1_0::DeviceMemory) -> Self {
12725 self.0.memory = memory as _;
12726 self
12727 }
12728 #[inline]
12729 #[must_use]
12730 pub fn memory_offset(mut self, memory_offset: crate::vk1_0::DeviceSize) -> Self {
12731 self.0.memory_offset = memory_offset as _;
12732 self
12733 }
12734 #[inline]
12735 #[must_use]
12736 pub fn flags(mut self, flags: crate::vk1_0::SparseMemoryBindFlags) -> Self {
12737 self.0.flags = flags as _;
12738 self
12739 }
12740 #[inline]
12741 pub fn build(self) -> SparseImageMemoryBind {
12742 self.0
12743 }
12744}
12745impl<'a> std::default::Default for SparseImageMemoryBindBuilder<'a> {
12746 fn default() -> SparseImageMemoryBindBuilder<'a> {
12747 Self::new()
12748 }
12749}
12750impl<'a> std::fmt::Debug for SparseImageMemoryBindBuilder<'a> {
12751 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12752 std::fmt::Debug::fmt(&self.0, f)
12753 }
12754}
12755impl<'a> std::ops::Deref for SparseImageMemoryBindBuilder<'a> {
12756 type Target = SparseImageMemoryBind;
12757 fn deref(&self) -> &Self::Target {
12758 &self.0
12759 }
12760}
12761impl<'a> std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> {
12762 fn deref_mut(&mut self) -> &mut Self::Target {
12763 &mut self.0
12764 }
12765}
12766#[doc(alias = "VkSparseBufferMemoryBindInfo")]
12768#[derive(Copy, Clone)]
12769#[repr(C)]
12770pub struct SparseBufferMemoryBindInfo {
12771 pub buffer: crate::vk1_0::Buffer,
12772 pub bind_count: u32,
12773 pub p_binds: *const crate::vk1_0::SparseMemoryBind,
12774}
12775impl Default for SparseBufferMemoryBindInfo {
12776 fn default() -> Self {
12777 Self {
12778 buffer: Default::default(),
12779 bind_count: Default::default(),
12780 p_binds: std::ptr::null(),
12781 }
12782 }
12783}
12784impl std::fmt::Debug for SparseBufferMemoryBindInfo {
12785 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12786 f.debug_struct("SparseBufferMemoryBindInfo")
12787 .field("buffer", &self.buffer)
12788 .field("bind_count", &self.bind_count)
12789 .field("p_binds", &self.p_binds)
12790 .finish()
12791 }
12792}
12793impl SparseBufferMemoryBindInfo {
12794 #[inline]
12795 pub fn into_builder<'a>(self) -> SparseBufferMemoryBindInfoBuilder<'a> {
12796 SparseBufferMemoryBindInfoBuilder(self, std::marker::PhantomData)
12797 }
12798}
12799#[derive(Copy, Clone)]
12800#[repr(transparent)]
12802pub struct SparseBufferMemoryBindInfoBuilder<'a>(
12803 SparseBufferMemoryBindInfo,
12804 std::marker::PhantomData<&'a ()>,
12805);
12806impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
12807 #[inline]
12808 pub fn new() -> SparseBufferMemoryBindInfoBuilder<'a> {
12809 SparseBufferMemoryBindInfoBuilder(Default::default(), std::marker::PhantomData)
12810 }
12811 #[inline]
12812 #[must_use]
12813 pub fn buffer(mut self, buffer: crate::vk1_0::Buffer) -> Self {
12814 self.0.buffer = buffer as _;
12815 self
12816 }
12817 #[inline]
12818 #[must_use]
12819 pub fn binds(mut self, binds: &'a [crate::vk1_0::SparseMemoryBindBuilder]) -> Self {
12820 self.0.p_binds = binds.as_ptr() as _;
12821 self.0.bind_count = binds.len() as _;
12822 self
12823 }
12824 #[inline]
12825 pub fn build_dangling(self) -> SparseBufferMemoryBindInfo {
12828 self.0
12829 }
12830}
12831impl<'a> std::default::Default for SparseBufferMemoryBindInfoBuilder<'a> {
12832 fn default() -> SparseBufferMemoryBindInfoBuilder<'a> {
12833 Self::new()
12834 }
12835}
12836impl<'a> std::fmt::Debug for SparseBufferMemoryBindInfoBuilder<'a> {
12837 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12838 std::fmt::Debug::fmt(&self.0, f)
12839 }
12840}
12841impl<'a> std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> {
12842 type Target = SparseBufferMemoryBindInfo;
12843 fn deref(&self) -> &Self::Target {
12844 &self.0
12845 }
12846}
12847impl<'a> std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> {
12848 fn deref_mut(&mut self) -> &mut Self::Target {
12849 &mut self.0
12850 }
12851}
12852#[doc(alias = "VkSparseImageOpaqueMemoryBindInfo")]
12854#[derive(Copy, Clone)]
12855#[repr(C)]
12856pub struct SparseImageOpaqueMemoryBindInfo {
12857 pub image: crate::vk1_0::Image,
12858 pub bind_count: u32,
12859 pub p_binds: *const crate::vk1_0::SparseMemoryBind,
12860}
12861impl Default for SparseImageOpaqueMemoryBindInfo {
12862 fn default() -> Self {
12863 Self {
12864 image: Default::default(),
12865 bind_count: Default::default(),
12866 p_binds: std::ptr::null(),
12867 }
12868 }
12869}
12870impl std::fmt::Debug for SparseImageOpaqueMemoryBindInfo {
12871 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12872 f.debug_struct("SparseImageOpaqueMemoryBindInfo")
12873 .field("image", &self.image)
12874 .field("bind_count", &self.bind_count)
12875 .field("p_binds", &self.p_binds)
12876 .finish()
12877 }
12878}
12879impl SparseImageOpaqueMemoryBindInfo {
12880 #[inline]
12881 pub fn into_builder<'a>(self) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
12882 SparseImageOpaqueMemoryBindInfoBuilder(self, std::marker::PhantomData)
12883 }
12884}
12885#[derive(Copy, Clone)]
12886#[repr(transparent)]
12888pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a>(
12889 SparseImageOpaqueMemoryBindInfo,
12890 std::marker::PhantomData<&'a ()>,
12891);
12892impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
12893 #[inline]
12894 pub fn new() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
12895 SparseImageOpaqueMemoryBindInfoBuilder(
12896 Default::default(),
12897 std::marker::PhantomData,
12898 )
12899 }
12900 #[inline]
12901 #[must_use]
12902 pub fn image(mut self, image: crate::vk1_0::Image) -> Self {
12903 self.0.image = image as _;
12904 self
12905 }
12906 #[inline]
12907 #[must_use]
12908 pub fn binds(mut self, binds: &'a [crate::vk1_0::SparseMemoryBindBuilder]) -> Self {
12909 self.0.p_binds = binds.as_ptr() as _;
12910 self.0.bind_count = binds.len() as _;
12911 self
12912 }
12913 #[inline]
12914 pub fn build_dangling(self) -> SparseImageOpaqueMemoryBindInfo {
12917 self.0
12918 }
12919}
12920impl<'a> std::default::Default for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
12921 fn default() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
12922 Self::new()
12923 }
12924}
12925impl<'a> std::fmt::Debug for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
12926 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12927 std::fmt::Debug::fmt(&self.0, f)
12928 }
12929}
12930impl<'a> std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
12931 type Target = SparseImageOpaqueMemoryBindInfo;
12932 fn deref(&self) -> &Self::Target {
12933 &self.0
12934 }
12935}
12936impl<'a> std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
12937 fn deref_mut(&mut self) -> &mut Self::Target {
12938 &mut self.0
12939 }
12940}
12941#[doc(alias = "VkSparseImageMemoryBindInfo")]
12943#[derive(Copy, Clone)]
12944#[repr(C)]
12945pub struct SparseImageMemoryBindInfo {
12946 pub image: crate::vk1_0::Image,
12947 pub bind_count: u32,
12948 pub p_binds: *const crate::vk1_0::SparseImageMemoryBind,
12949}
12950impl Default for SparseImageMemoryBindInfo {
12951 fn default() -> Self {
12952 Self {
12953 image: Default::default(),
12954 bind_count: Default::default(),
12955 p_binds: std::ptr::null(),
12956 }
12957 }
12958}
12959impl std::fmt::Debug for SparseImageMemoryBindInfo {
12960 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
12961 f.debug_struct("SparseImageMemoryBindInfo")
12962 .field("image", &self.image)
12963 .field("bind_count", &self.bind_count)
12964 .field("p_binds", &self.p_binds)
12965 .finish()
12966 }
12967}
12968impl SparseImageMemoryBindInfo {
12969 #[inline]
12970 pub fn into_builder<'a>(self) -> SparseImageMemoryBindInfoBuilder<'a> {
12971 SparseImageMemoryBindInfoBuilder(self, std::marker::PhantomData)
12972 }
12973}
12974#[derive(Copy, Clone)]
12975#[repr(transparent)]
12977pub struct SparseImageMemoryBindInfoBuilder<'a>(
12978 SparseImageMemoryBindInfo,
12979 std::marker::PhantomData<&'a ()>,
12980);
12981impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
12982 #[inline]
12983 pub fn new() -> SparseImageMemoryBindInfoBuilder<'a> {
12984 SparseImageMemoryBindInfoBuilder(Default::default(), std::marker::PhantomData)
12985 }
12986 #[inline]
12987 #[must_use]
12988 pub fn image(mut self, image: crate::vk1_0::Image) -> Self {
12989 self.0.image = image as _;
12990 self
12991 }
12992 #[inline]
12993 #[must_use]
12994 pub fn binds(
12995 mut self,
12996 binds: &'a [crate::vk1_0::SparseImageMemoryBindBuilder],
12997 ) -> Self {
12998 self.0.p_binds = binds.as_ptr() as _;
12999 self.0.bind_count = binds.len() as _;
13000 self
13001 }
13002 #[inline]
13003 pub fn build_dangling(self) -> SparseImageMemoryBindInfo {
13006 self.0
13007 }
13008}
13009impl<'a> std::default::Default for SparseImageMemoryBindInfoBuilder<'a> {
13010 fn default() -> SparseImageMemoryBindInfoBuilder<'a> {
13011 Self::new()
13012 }
13013}
13014impl<'a> std::fmt::Debug for SparseImageMemoryBindInfoBuilder<'a> {
13015 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13016 std::fmt::Debug::fmt(&self.0, f)
13017 }
13018}
13019impl<'a> std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> {
13020 type Target = SparseImageMemoryBindInfo;
13021 fn deref(&self) -> &Self::Target {
13022 &self.0
13023 }
13024}
13025impl<'a> std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> {
13026 fn deref_mut(&mut self) -> &mut Self::Target {
13027 &mut self.0
13028 }
13029}
13030#[doc(alias = "VkBindSparseInfo")]
13032#[derive(Copy, Clone)]
13033#[repr(C)]
13034pub struct BindSparseInfo {
13035 pub s_type: crate::vk1_0::StructureType,
13036 pub p_next: *const std::ffi::c_void,
13037 pub wait_semaphore_count: u32,
13038 pub p_wait_semaphores: *const crate::vk1_0::Semaphore,
13039 pub buffer_bind_count: u32,
13040 pub p_buffer_binds: *const crate::vk1_0::SparseBufferMemoryBindInfo,
13041 pub image_opaque_bind_count: u32,
13042 pub p_image_opaque_binds: *const crate::vk1_0::SparseImageOpaqueMemoryBindInfo,
13043 pub image_bind_count: u32,
13044 pub p_image_binds: *const crate::vk1_0::SparseImageMemoryBindInfo,
13045 pub signal_semaphore_count: u32,
13046 pub p_signal_semaphores: *const crate::vk1_0::Semaphore,
13047}
13048impl BindSparseInfo {
13049 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::BIND_SPARSE_INFO;
13050}
13051impl Default for BindSparseInfo {
13052 fn default() -> Self {
13053 Self {
13054 s_type: Self::STRUCTURE_TYPE,
13055 p_next: std::ptr::null(),
13056 wait_semaphore_count: Default::default(),
13057 p_wait_semaphores: std::ptr::null(),
13058 buffer_bind_count: Default::default(),
13059 p_buffer_binds: std::ptr::null(),
13060 image_opaque_bind_count: Default::default(),
13061 p_image_opaque_binds: std::ptr::null(),
13062 image_bind_count: Default::default(),
13063 p_image_binds: std::ptr::null(),
13064 signal_semaphore_count: Default::default(),
13065 p_signal_semaphores: std::ptr::null(),
13066 }
13067 }
13068}
13069impl std::fmt::Debug for BindSparseInfo {
13070 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13071 f.debug_struct("BindSparseInfo")
13072 .field("s_type", &self.s_type)
13073 .field("p_next", &self.p_next)
13074 .field("wait_semaphore_count", &self.wait_semaphore_count)
13075 .field("p_wait_semaphores", &self.p_wait_semaphores)
13076 .field("buffer_bind_count", &self.buffer_bind_count)
13077 .field("p_buffer_binds", &self.p_buffer_binds)
13078 .field("image_opaque_bind_count", &self.image_opaque_bind_count)
13079 .field("p_image_opaque_binds", &self.p_image_opaque_binds)
13080 .field("image_bind_count", &self.image_bind_count)
13081 .field("p_image_binds", &self.p_image_binds)
13082 .field("signal_semaphore_count", &self.signal_semaphore_count)
13083 .field("p_signal_semaphores", &self.p_signal_semaphores)
13084 .finish()
13085 }
13086}
13087impl BindSparseInfo {
13088 #[inline]
13089 pub fn into_builder<'a>(self) -> BindSparseInfoBuilder<'a> {
13090 BindSparseInfoBuilder(self, std::marker::PhantomData)
13091 }
13092}
13093#[derive(Copy, Clone)]
13094#[repr(transparent)]
13096pub struct BindSparseInfoBuilder<'a>(BindSparseInfo, std::marker::PhantomData<&'a ()>);
13097impl<'a> BindSparseInfoBuilder<'a> {
13098 #[inline]
13099 pub fn new() -> BindSparseInfoBuilder<'a> {
13100 BindSparseInfoBuilder(Default::default(), std::marker::PhantomData)
13101 }
13102 #[inline]
13103 #[must_use]
13104 pub fn wait_semaphores(
13105 mut self,
13106 wait_semaphores: &'a [crate::vk1_0::Semaphore],
13107 ) -> Self {
13108 self.0.p_wait_semaphores = wait_semaphores.as_ptr() as _;
13109 self.0.wait_semaphore_count = wait_semaphores.len() as _;
13110 self
13111 }
13112 #[inline]
13113 #[must_use]
13114 pub fn buffer_binds(
13115 mut self,
13116 buffer_binds: &'a [crate::vk1_0::SparseBufferMemoryBindInfoBuilder],
13117 ) -> Self {
13118 self.0.p_buffer_binds = buffer_binds.as_ptr() as _;
13119 self.0.buffer_bind_count = buffer_binds.len() as _;
13120 self
13121 }
13122 #[inline]
13123 #[must_use]
13124 pub fn image_opaque_binds(
13125 mut self,
13126 image_opaque_binds: &'a [crate::vk1_0::SparseImageOpaqueMemoryBindInfoBuilder],
13127 ) -> Self {
13128 self.0.p_image_opaque_binds = image_opaque_binds.as_ptr() as _;
13129 self.0.image_opaque_bind_count = image_opaque_binds.len() as _;
13130 self
13131 }
13132 #[inline]
13133 #[must_use]
13134 pub fn image_binds(
13135 mut self,
13136 image_binds: &'a [crate::vk1_0::SparseImageMemoryBindInfoBuilder],
13137 ) -> Self {
13138 self.0.p_image_binds = image_binds.as_ptr() as _;
13139 self.0.image_bind_count = image_binds.len() as _;
13140 self
13141 }
13142 #[inline]
13143 #[must_use]
13144 pub fn signal_semaphores(
13145 mut self,
13146 signal_semaphores: &'a [crate::vk1_0::Semaphore],
13147 ) -> Self {
13148 self.0.p_signal_semaphores = signal_semaphores.as_ptr() as _;
13149 self.0.signal_semaphore_count = signal_semaphores.len() as _;
13150 self
13151 }
13152 #[inline]
13153 pub fn build_dangling(self) -> BindSparseInfo {
13156 self.0
13157 }
13158}
13159impl<'a> std::default::Default for BindSparseInfoBuilder<'a> {
13160 fn default() -> BindSparseInfoBuilder<'a> {
13161 Self::new()
13162 }
13163}
13164impl<'a> std::fmt::Debug for BindSparseInfoBuilder<'a> {
13165 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13166 std::fmt::Debug::fmt(&self.0, f)
13167 }
13168}
13169impl<'a> std::ops::Deref for BindSparseInfoBuilder<'a> {
13170 type Target = BindSparseInfo;
13171 fn deref(&self) -> &Self::Target {
13172 &self.0
13173 }
13174}
13175impl<'a> std::ops::DerefMut for BindSparseInfoBuilder<'a> {
13176 fn deref_mut(&mut self) -> &mut Self::Target {
13177 &mut self.0
13178 }
13179}
13180#[doc(alias = "VkImageCopy")]
13182#[derive(Copy, Clone, Hash, PartialEq, Eq)]
13183#[repr(C)]
13184pub struct ImageCopy {
13185 pub src_subresource: crate::vk1_0::ImageSubresourceLayers,
13186 pub src_offset: crate::vk1_0::Offset3D,
13187 pub dst_subresource: crate::vk1_0::ImageSubresourceLayers,
13188 pub dst_offset: crate::vk1_0::Offset3D,
13189 pub extent: crate::vk1_0::Extent3D,
13190}
13191impl Default for ImageCopy {
13192 fn default() -> Self {
13193 Self {
13194 src_subresource: Default::default(),
13195 src_offset: Default::default(),
13196 dst_subresource: Default::default(),
13197 dst_offset: Default::default(),
13198 extent: Default::default(),
13199 }
13200 }
13201}
13202impl std::fmt::Debug for ImageCopy {
13203 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13204 f.debug_struct("ImageCopy")
13205 .field("src_subresource", &self.src_subresource)
13206 .field("src_offset", &self.src_offset)
13207 .field("dst_subresource", &self.dst_subresource)
13208 .field("dst_offset", &self.dst_offset)
13209 .field("extent", &self.extent)
13210 .finish()
13211 }
13212}
13213impl ImageCopy {
13214 #[inline]
13215 pub fn into_builder<'a>(self) -> ImageCopyBuilder<'a> {
13216 ImageCopyBuilder(self, std::marker::PhantomData)
13217 }
13218}
13219#[derive(Copy, Clone)]
13220#[repr(transparent)]
13222pub struct ImageCopyBuilder<'a>(ImageCopy, std::marker::PhantomData<&'a ()>);
13223impl<'a> ImageCopyBuilder<'a> {
13224 #[inline]
13225 pub fn new() -> ImageCopyBuilder<'a> {
13226 ImageCopyBuilder(Default::default(), std::marker::PhantomData)
13227 }
13228 #[inline]
13229 #[must_use]
13230 pub fn src_subresource(
13231 mut self,
13232 src_subresource: crate::vk1_0::ImageSubresourceLayers,
13233 ) -> Self {
13234 self.0.src_subresource = src_subresource as _;
13235 self
13236 }
13237 #[inline]
13238 #[must_use]
13239 pub fn src_offset(mut self, src_offset: crate::vk1_0::Offset3D) -> Self {
13240 self.0.src_offset = src_offset as _;
13241 self
13242 }
13243 #[inline]
13244 #[must_use]
13245 pub fn dst_subresource(
13246 mut self,
13247 dst_subresource: crate::vk1_0::ImageSubresourceLayers,
13248 ) -> Self {
13249 self.0.dst_subresource = dst_subresource as _;
13250 self
13251 }
13252 #[inline]
13253 #[must_use]
13254 pub fn dst_offset(mut self, dst_offset: crate::vk1_0::Offset3D) -> Self {
13255 self.0.dst_offset = dst_offset as _;
13256 self
13257 }
13258 #[inline]
13259 #[must_use]
13260 pub fn extent(mut self, extent: crate::vk1_0::Extent3D) -> Self {
13261 self.0.extent = extent as _;
13262 self
13263 }
13264 #[inline]
13265 pub fn build(self) -> ImageCopy {
13266 self.0
13267 }
13268}
13269impl<'a> std::default::Default for ImageCopyBuilder<'a> {
13270 fn default() -> ImageCopyBuilder<'a> {
13271 Self::new()
13272 }
13273}
13274impl<'a> std::fmt::Debug for ImageCopyBuilder<'a> {
13275 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13276 std::fmt::Debug::fmt(&self.0, f)
13277 }
13278}
13279impl<'a> std::ops::Deref for ImageCopyBuilder<'a> {
13280 type Target = ImageCopy;
13281 fn deref(&self) -> &Self::Target {
13282 &self.0
13283 }
13284}
13285impl<'a> std::ops::DerefMut for ImageCopyBuilder<'a> {
13286 fn deref_mut(&mut self) -> &mut Self::Target {
13287 &mut self.0
13288 }
13289}
13290#[doc(alias = "VkImageBlit")]
13292#[derive(Copy, Clone, Hash, PartialEq, Eq)]
13293#[repr(C)]
13294pub struct ImageBlit {
13295 pub src_subresource: crate::vk1_0::ImageSubresourceLayers,
13296 pub src_offsets: [crate::vk1_0::Offset3D; 2],
13297 pub dst_subresource: crate::vk1_0::ImageSubresourceLayers,
13298 pub dst_offsets: [crate::vk1_0::Offset3D; 2],
13299}
13300impl Default for ImageBlit {
13301 fn default() -> Self {
13302 Self {
13303 src_subresource: Default::default(),
13304 src_offsets: unsafe { std::mem::zeroed() },
13305 dst_subresource: Default::default(),
13306 dst_offsets: unsafe { std::mem::zeroed() },
13307 }
13308 }
13309}
13310impl std::fmt::Debug for ImageBlit {
13311 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13312 f.debug_struct("ImageBlit")
13313 .field("src_subresource", &self.src_subresource)
13314 .field("src_offsets", &self.src_offsets)
13315 .field("dst_subresource", &self.dst_subresource)
13316 .field("dst_offsets", &self.dst_offsets)
13317 .finish()
13318 }
13319}
13320impl ImageBlit {
13321 #[inline]
13322 pub fn into_builder<'a>(self) -> ImageBlitBuilder<'a> {
13323 ImageBlitBuilder(self, std::marker::PhantomData)
13324 }
13325}
13326#[derive(Copy, Clone)]
13327#[repr(transparent)]
13329pub struct ImageBlitBuilder<'a>(ImageBlit, std::marker::PhantomData<&'a ()>);
13330impl<'a> ImageBlitBuilder<'a> {
13331 #[inline]
13332 pub fn new() -> ImageBlitBuilder<'a> {
13333 ImageBlitBuilder(Default::default(), std::marker::PhantomData)
13334 }
13335 #[inline]
13336 #[must_use]
13337 pub fn src_subresource(
13338 mut self,
13339 src_subresource: crate::vk1_0::ImageSubresourceLayers,
13340 ) -> Self {
13341 self.0.src_subresource = src_subresource as _;
13342 self
13343 }
13344 #[inline]
13345 #[must_use]
13346 pub fn src_offsets(mut self, src_offsets: [crate::vk1_0::Offset3D; 2]) -> Self {
13347 self.0.src_offsets = src_offsets as _;
13348 self
13349 }
13350 #[inline]
13351 #[must_use]
13352 pub fn dst_subresource(
13353 mut self,
13354 dst_subresource: crate::vk1_0::ImageSubresourceLayers,
13355 ) -> Self {
13356 self.0.dst_subresource = dst_subresource as _;
13357 self
13358 }
13359 #[inline]
13360 #[must_use]
13361 pub fn dst_offsets(mut self, dst_offsets: [crate::vk1_0::Offset3D; 2]) -> Self {
13362 self.0.dst_offsets = dst_offsets as _;
13363 self
13364 }
13365 #[inline]
13366 pub fn build(self) -> ImageBlit {
13367 self.0
13368 }
13369}
13370impl<'a> std::default::Default for ImageBlitBuilder<'a> {
13371 fn default() -> ImageBlitBuilder<'a> {
13372 Self::new()
13373 }
13374}
13375impl<'a> std::fmt::Debug for ImageBlitBuilder<'a> {
13376 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13377 std::fmt::Debug::fmt(&self.0, f)
13378 }
13379}
13380impl<'a> std::ops::Deref for ImageBlitBuilder<'a> {
13381 type Target = ImageBlit;
13382 fn deref(&self) -> &Self::Target {
13383 &self.0
13384 }
13385}
13386impl<'a> std::ops::DerefMut for ImageBlitBuilder<'a> {
13387 fn deref_mut(&mut self) -> &mut Self::Target {
13388 &mut self.0
13389 }
13390}
13391#[doc(alias = "VkBufferImageCopy")]
13393#[derive(Copy, Clone, Hash, PartialEq, Eq)]
13394#[repr(C)]
13395pub struct BufferImageCopy {
13396 pub buffer_offset: crate::vk1_0::DeviceSize,
13397 pub buffer_row_length: u32,
13398 pub buffer_image_height: u32,
13399 pub image_subresource: crate::vk1_0::ImageSubresourceLayers,
13400 pub image_offset: crate::vk1_0::Offset3D,
13401 pub image_extent: crate::vk1_0::Extent3D,
13402}
13403impl Default for BufferImageCopy {
13404 fn default() -> Self {
13405 Self {
13406 buffer_offset: Default::default(),
13407 buffer_row_length: Default::default(),
13408 buffer_image_height: Default::default(),
13409 image_subresource: Default::default(),
13410 image_offset: Default::default(),
13411 image_extent: Default::default(),
13412 }
13413 }
13414}
13415impl std::fmt::Debug for BufferImageCopy {
13416 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13417 f.debug_struct("BufferImageCopy")
13418 .field("buffer_offset", &self.buffer_offset)
13419 .field("buffer_row_length", &self.buffer_row_length)
13420 .field("buffer_image_height", &self.buffer_image_height)
13421 .field("image_subresource", &self.image_subresource)
13422 .field("image_offset", &self.image_offset)
13423 .field("image_extent", &self.image_extent)
13424 .finish()
13425 }
13426}
13427impl BufferImageCopy {
13428 #[inline]
13429 pub fn into_builder<'a>(self) -> BufferImageCopyBuilder<'a> {
13430 BufferImageCopyBuilder(self, std::marker::PhantomData)
13431 }
13432}
13433#[derive(Copy, Clone)]
13434#[repr(transparent)]
13436pub struct BufferImageCopyBuilder<'a>(BufferImageCopy, std::marker::PhantomData<&'a ()>);
13437impl<'a> BufferImageCopyBuilder<'a> {
13438 #[inline]
13439 pub fn new() -> BufferImageCopyBuilder<'a> {
13440 BufferImageCopyBuilder(Default::default(), std::marker::PhantomData)
13441 }
13442 #[inline]
13443 #[must_use]
13444 pub fn buffer_offset(mut self, buffer_offset: crate::vk1_0::DeviceSize) -> Self {
13445 self.0.buffer_offset = buffer_offset as _;
13446 self
13447 }
13448 #[inline]
13449 #[must_use]
13450 pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
13451 self.0.buffer_row_length = buffer_row_length as _;
13452 self
13453 }
13454 #[inline]
13455 #[must_use]
13456 pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
13457 self.0.buffer_image_height = buffer_image_height as _;
13458 self
13459 }
13460 #[inline]
13461 #[must_use]
13462 pub fn image_subresource(
13463 mut self,
13464 image_subresource: crate::vk1_0::ImageSubresourceLayers,
13465 ) -> Self {
13466 self.0.image_subresource = image_subresource as _;
13467 self
13468 }
13469 #[inline]
13470 #[must_use]
13471 pub fn image_offset(mut self, image_offset: crate::vk1_0::Offset3D) -> Self {
13472 self.0.image_offset = image_offset as _;
13473 self
13474 }
13475 #[inline]
13476 #[must_use]
13477 pub fn image_extent(mut self, image_extent: crate::vk1_0::Extent3D) -> Self {
13478 self.0.image_extent = image_extent as _;
13479 self
13480 }
13481 #[inline]
13482 pub fn build(self) -> BufferImageCopy {
13483 self.0
13484 }
13485}
13486impl<'a> std::default::Default for BufferImageCopyBuilder<'a> {
13487 fn default() -> BufferImageCopyBuilder<'a> {
13488 Self::new()
13489 }
13490}
13491impl<'a> std::fmt::Debug for BufferImageCopyBuilder<'a> {
13492 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13493 std::fmt::Debug::fmt(&self.0, f)
13494 }
13495}
13496impl<'a> std::ops::Deref for BufferImageCopyBuilder<'a> {
13497 type Target = BufferImageCopy;
13498 fn deref(&self) -> &Self::Target {
13499 &self.0
13500 }
13501}
13502impl<'a> std::ops::DerefMut for BufferImageCopyBuilder<'a> {
13503 fn deref_mut(&mut self) -> &mut Self::Target {
13504 &mut self.0
13505 }
13506}
13507#[doc(alias = "VkImageResolve")]
13509#[derive(Copy, Clone, Hash, PartialEq, Eq)]
13510#[repr(C)]
13511pub struct ImageResolve {
13512 pub src_subresource: crate::vk1_0::ImageSubresourceLayers,
13513 pub src_offset: crate::vk1_0::Offset3D,
13514 pub dst_subresource: crate::vk1_0::ImageSubresourceLayers,
13515 pub dst_offset: crate::vk1_0::Offset3D,
13516 pub extent: crate::vk1_0::Extent3D,
13517}
13518impl Default for ImageResolve {
13519 fn default() -> Self {
13520 Self {
13521 src_subresource: Default::default(),
13522 src_offset: Default::default(),
13523 dst_subresource: Default::default(),
13524 dst_offset: Default::default(),
13525 extent: Default::default(),
13526 }
13527 }
13528}
13529impl std::fmt::Debug for ImageResolve {
13530 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13531 f.debug_struct("ImageResolve")
13532 .field("src_subresource", &self.src_subresource)
13533 .field("src_offset", &self.src_offset)
13534 .field("dst_subresource", &self.dst_subresource)
13535 .field("dst_offset", &self.dst_offset)
13536 .field("extent", &self.extent)
13537 .finish()
13538 }
13539}
13540impl ImageResolve {
13541 #[inline]
13542 pub fn into_builder<'a>(self) -> ImageResolveBuilder<'a> {
13543 ImageResolveBuilder(self, std::marker::PhantomData)
13544 }
13545}
13546#[derive(Copy, Clone)]
13547#[repr(transparent)]
13549pub struct ImageResolveBuilder<'a>(ImageResolve, std::marker::PhantomData<&'a ()>);
13550impl<'a> ImageResolveBuilder<'a> {
13551 #[inline]
13552 pub fn new() -> ImageResolveBuilder<'a> {
13553 ImageResolveBuilder(Default::default(), std::marker::PhantomData)
13554 }
13555 #[inline]
13556 #[must_use]
13557 pub fn src_subresource(
13558 mut self,
13559 src_subresource: crate::vk1_0::ImageSubresourceLayers,
13560 ) -> Self {
13561 self.0.src_subresource = src_subresource as _;
13562 self
13563 }
13564 #[inline]
13565 #[must_use]
13566 pub fn src_offset(mut self, src_offset: crate::vk1_0::Offset3D) -> Self {
13567 self.0.src_offset = src_offset as _;
13568 self
13569 }
13570 #[inline]
13571 #[must_use]
13572 pub fn dst_subresource(
13573 mut self,
13574 dst_subresource: crate::vk1_0::ImageSubresourceLayers,
13575 ) -> Self {
13576 self.0.dst_subresource = dst_subresource as _;
13577 self
13578 }
13579 #[inline]
13580 #[must_use]
13581 pub fn dst_offset(mut self, dst_offset: crate::vk1_0::Offset3D) -> Self {
13582 self.0.dst_offset = dst_offset as _;
13583 self
13584 }
13585 #[inline]
13586 #[must_use]
13587 pub fn extent(mut self, extent: crate::vk1_0::Extent3D) -> Self {
13588 self.0.extent = extent as _;
13589 self
13590 }
13591 #[inline]
13592 pub fn build(self) -> ImageResolve {
13593 self.0
13594 }
13595}
13596impl<'a> std::default::Default for ImageResolveBuilder<'a> {
13597 fn default() -> ImageResolveBuilder<'a> {
13598 Self::new()
13599 }
13600}
13601impl<'a> std::fmt::Debug for ImageResolveBuilder<'a> {
13602 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13603 std::fmt::Debug::fmt(&self.0, f)
13604 }
13605}
13606impl<'a> std::ops::Deref for ImageResolveBuilder<'a> {
13607 type Target = ImageResolve;
13608 fn deref(&self) -> &Self::Target {
13609 &self.0
13610 }
13611}
13612impl<'a> std::ops::DerefMut for ImageResolveBuilder<'a> {
13613 fn deref_mut(&mut self) -> &mut Self::Target {
13614 &mut self.0
13615 }
13616}
13617#[doc(alias = "VkShaderModuleCreateInfo")]
13619#[derive(Copy, Clone)]
13620#[repr(C)]
13621pub struct ShaderModuleCreateInfo {
13622 pub s_type: crate::vk1_0::StructureType,
13623 pub p_next: *const std::ffi::c_void,
13624 pub flags: crate::vk1_0::ShaderModuleCreateFlags,
13625 pub code_size: usize,
13626 pub p_code: *const u32,
13627}
13628impl ShaderModuleCreateInfo {
13629 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::SHADER_MODULE_CREATE_INFO;
13630}
13631impl Default for ShaderModuleCreateInfo {
13632 fn default() -> Self {
13633 Self {
13634 s_type: Self::STRUCTURE_TYPE,
13635 p_next: std::ptr::null(),
13636 flags: Default::default(),
13637 code_size: Default::default(),
13638 p_code: std::ptr::null(),
13639 }
13640 }
13641}
13642impl std::fmt::Debug for ShaderModuleCreateInfo {
13643 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13644 f.debug_struct("ShaderModuleCreateInfo")
13645 .field("s_type", &self.s_type)
13646 .field("p_next", &self.p_next)
13647 .field("flags", &self.flags)
13648 .field("code_size", &self.code_size)
13649 .field("p_code", &self.p_code)
13650 .finish()
13651 }
13652}
13653impl ShaderModuleCreateInfo {
13654 #[inline]
13655 pub fn into_builder<'a>(self) -> ShaderModuleCreateInfoBuilder<'a> {
13656 ShaderModuleCreateInfoBuilder(self, std::marker::PhantomData)
13657 }
13658}
13659#[derive(Copy, Clone)]
13660#[repr(transparent)]
13662pub struct ShaderModuleCreateInfoBuilder<'a>(
13663 ShaderModuleCreateInfo,
13664 std::marker::PhantomData<&'a ()>,
13665);
13666impl<'a> ShaderModuleCreateInfoBuilder<'a> {
13667 #[inline]
13668 pub fn new() -> ShaderModuleCreateInfoBuilder<'a> {
13669 ShaderModuleCreateInfoBuilder(Default::default(), std::marker::PhantomData)
13670 }
13671 #[inline]
13672 #[must_use]
13673 pub fn flags(mut self, flags: crate::vk1_0::ShaderModuleCreateFlags) -> Self {
13674 self.0.flags = flags as _;
13675 self
13676 }
13677 #[inline]
13678 #[must_use]
13679 pub fn code(mut self, code: &'a [u32]) -> Self {
13680 self.0.p_code = code.as_ptr() as _;
13681 self.0.code_size = code.len() * 4;
13682 self
13683 }
13684 #[inline]
13685 pub fn build_dangling(self) -> ShaderModuleCreateInfo {
13688 self.0
13689 }
13690}
13691impl<'a> std::default::Default for ShaderModuleCreateInfoBuilder<'a> {
13692 fn default() -> ShaderModuleCreateInfoBuilder<'a> {
13693 Self::new()
13694 }
13695}
13696impl<'a> std::fmt::Debug for ShaderModuleCreateInfoBuilder<'a> {
13697 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13698 std::fmt::Debug::fmt(&self.0, f)
13699 }
13700}
13701impl<'a> std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> {
13702 type Target = ShaderModuleCreateInfo;
13703 fn deref(&self) -> &Self::Target {
13704 &self.0
13705 }
13706}
13707impl<'a> std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> {
13708 fn deref_mut(&mut self) -> &mut Self::Target {
13709 &mut self.0
13710 }
13711}
13712#[doc(alias = "VkDescriptorSetLayoutBinding")]
13714#[derive(Copy, Clone)]
13715#[repr(C)]
13716pub struct DescriptorSetLayoutBinding {
13717 pub binding: u32,
13718 pub descriptor_type: crate::vk1_0::DescriptorType,
13719 pub descriptor_count: u32,
13720 pub stage_flags: crate::vk1_0::ShaderStageFlags,
13721 pub p_immutable_samplers: *const crate::vk1_0::Sampler,
13722}
13723impl Default for DescriptorSetLayoutBinding {
13724 fn default() -> Self {
13725 Self {
13726 binding: Default::default(),
13727 descriptor_type: Default::default(),
13728 descriptor_count: Default::default(),
13729 stage_flags: Default::default(),
13730 p_immutable_samplers: std::ptr::null(),
13731 }
13732 }
13733}
13734impl std::fmt::Debug for DescriptorSetLayoutBinding {
13735 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13736 f.debug_struct("DescriptorSetLayoutBinding")
13737 .field("binding", &self.binding)
13738 .field("descriptor_type", &self.descriptor_type)
13739 .field("descriptor_count", &self.descriptor_count)
13740 .field("stage_flags", &self.stage_flags)
13741 .field("p_immutable_samplers", &self.p_immutable_samplers)
13742 .finish()
13743 }
13744}
13745impl DescriptorSetLayoutBinding {
13746 #[inline]
13747 pub fn into_builder<'a>(self) -> DescriptorSetLayoutBindingBuilder<'a> {
13748 DescriptorSetLayoutBindingBuilder(self, std::marker::PhantomData)
13749 }
13750}
13751#[derive(Copy, Clone)]
13752#[repr(transparent)]
13754pub struct DescriptorSetLayoutBindingBuilder<'a>(
13755 DescriptorSetLayoutBinding,
13756 std::marker::PhantomData<&'a ()>,
13757);
13758impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
13759 #[inline]
13760 pub fn new() -> DescriptorSetLayoutBindingBuilder<'a> {
13761 DescriptorSetLayoutBindingBuilder(Default::default(), std::marker::PhantomData)
13762 }
13763 #[inline]
13764 #[must_use]
13765 pub fn binding(mut self, binding: u32) -> Self {
13766 self.0.binding = binding as _;
13767 self
13768 }
13769 #[inline]
13770 #[must_use]
13771 pub fn descriptor_type(
13772 mut self,
13773 descriptor_type: crate::vk1_0::DescriptorType,
13774 ) -> Self {
13775 self.0.descriptor_type = descriptor_type as _;
13776 self
13777 }
13778 #[inline]
13779 #[must_use]
13780 pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
13781 self.0.descriptor_count = descriptor_count as _;
13782 self
13783 }
13784 #[inline]
13785 #[must_use]
13786 pub fn stage_flags(mut self, stage_flags: crate::vk1_0::ShaderStageFlags) -> Self {
13787 self.0.stage_flags = stage_flags as _;
13788 self
13789 }
13790 #[inline]
13791 #[must_use]
13792 pub fn immutable_samplers(
13793 mut self,
13794 immutable_samplers: &'a [crate::vk1_0::Sampler],
13795 ) -> Self {
13796 self.0.p_immutable_samplers = immutable_samplers.as_ptr() as _;
13797 self.0.descriptor_count = immutable_samplers.len() as _;
13798 self
13799 }
13800 #[inline]
13801 pub fn build_dangling(self) -> DescriptorSetLayoutBinding {
13804 self.0
13805 }
13806}
13807impl<'a> std::default::Default for DescriptorSetLayoutBindingBuilder<'a> {
13808 fn default() -> DescriptorSetLayoutBindingBuilder<'a> {
13809 Self::new()
13810 }
13811}
13812impl<'a> std::fmt::Debug for DescriptorSetLayoutBindingBuilder<'a> {
13813 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13814 std::fmt::Debug::fmt(&self.0, f)
13815 }
13816}
13817impl<'a> std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> {
13818 type Target = DescriptorSetLayoutBinding;
13819 fn deref(&self) -> &Self::Target {
13820 &self.0
13821 }
13822}
13823impl<'a> std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> {
13824 fn deref_mut(&mut self) -> &mut Self::Target {
13825 &mut self.0
13826 }
13827}
13828#[doc(alias = "VkDescriptorSetLayoutCreateInfo")]
13830#[derive(Copy, Clone)]
13831#[repr(C)]
13832pub struct DescriptorSetLayoutCreateInfo {
13833 pub s_type: crate::vk1_0::StructureType,
13834 pub p_next: *const std::ffi::c_void,
13835 pub flags: crate::vk1_0::DescriptorSetLayoutCreateFlags,
13836 pub binding_count: u32,
13837 pub p_bindings: *const crate::vk1_0::DescriptorSetLayoutBinding,
13838}
13839impl DescriptorSetLayoutCreateInfo {
13840 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
13841}
13842impl Default for DescriptorSetLayoutCreateInfo {
13843 fn default() -> Self {
13844 Self {
13845 s_type: Self::STRUCTURE_TYPE,
13846 p_next: std::ptr::null(),
13847 flags: Default::default(),
13848 binding_count: Default::default(),
13849 p_bindings: std::ptr::null(),
13850 }
13851 }
13852}
13853impl std::fmt::Debug for DescriptorSetLayoutCreateInfo {
13854 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13855 f.debug_struct("DescriptorSetLayoutCreateInfo")
13856 .field("s_type", &self.s_type)
13857 .field("p_next", &self.p_next)
13858 .field("flags", &self.flags)
13859 .field("binding_count", &self.binding_count)
13860 .field("p_bindings", &self.p_bindings)
13861 .finish()
13862 }
13863}
13864impl DescriptorSetLayoutCreateInfo {
13865 #[inline]
13866 pub fn into_builder<'a>(self) -> DescriptorSetLayoutCreateInfoBuilder<'a> {
13867 DescriptorSetLayoutCreateInfoBuilder(self, std::marker::PhantomData)
13868 }
13869}
13870#[derive(Copy, Clone)]
13871#[repr(transparent)]
13873pub struct DescriptorSetLayoutCreateInfoBuilder<'a>(
13874 DescriptorSetLayoutCreateInfo,
13875 std::marker::PhantomData<&'a ()>,
13876);
13877impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
13878 #[inline]
13879 pub fn new() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
13880 DescriptorSetLayoutCreateInfoBuilder(
13881 Default::default(),
13882 std::marker::PhantomData,
13883 )
13884 }
13885 #[inline]
13886 #[must_use]
13887 pub fn flags(mut self, flags: crate::vk1_0::DescriptorSetLayoutCreateFlags) -> Self {
13888 self.0.flags = flags as _;
13889 self
13890 }
13891 #[inline]
13892 #[must_use]
13893 pub fn bindings(
13894 mut self,
13895 bindings: &'a [crate::vk1_0::DescriptorSetLayoutBindingBuilder],
13896 ) -> Self {
13897 self.0.p_bindings = bindings.as_ptr() as _;
13898 self.0.binding_count = bindings.len() as _;
13899 self
13900 }
13901 #[inline]
13902 pub fn build_dangling(self) -> DescriptorSetLayoutCreateInfo {
13905 self.0
13906 }
13907}
13908impl<'a> std::default::Default for DescriptorSetLayoutCreateInfoBuilder<'a> {
13909 fn default() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
13910 Self::new()
13911 }
13912}
13913impl<'a> std::fmt::Debug for DescriptorSetLayoutCreateInfoBuilder<'a> {
13914 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13915 std::fmt::Debug::fmt(&self.0, f)
13916 }
13917}
13918impl<'a> std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> {
13919 type Target = DescriptorSetLayoutCreateInfo;
13920 fn deref(&self) -> &Self::Target {
13921 &self.0
13922 }
13923}
13924impl<'a> std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> {
13925 fn deref_mut(&mut self) -> &mut Self::Target {
13926 &mut self.0
13927 }
13928}
13929#[doc(alias = "VkDescriptorPoolSize")]
13931#[derive(Copy, Clone, Hash, PartialEq, Eq)]
13932#[repr(C)]
13933pub struct DescriptorPoolSize {
13934 pub _type: crate::vk1_0::DescriptorType,
13935 pub descriptor_count: u32,
13936}
13937impl Default for DescriptorPoolSize {
13938 fn default() -> Self {
13939 Self {
13940 _type: Default::default(),
13941 descriptor_count: Default::default(),
13942 }
13943 }
13944}
13945impl std::fmt::Debug for DescriptorPoolSize {
13946 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13947 f.debug_struct("DescriptorPoolSize")
13948 .field("_type", &self._type)
13949 .field("descriptor_count", &self.descriptor_count)
13950 .finish()
13951 }
13952}
13953impl DescriptorPoolSize {
13954 #[inline]
13955 pub fn into_builder<'a>(self) -> DescriptorPoolSizeBuilder<'a> {
13956 DescriptorPoolSizeBuilder(self, std::marker::PhantomData)
13957 }
13958}
13959#[derive(Copy, Clone)]
13960#[repr(transparent)]
13962pub struct DescriptorPoolSizeBuilder<'a>(
13963 DescriptorPoolSize,
13964 std::marker::PhantomData<&'a ()>,
13965);
13966impl<'a> DescriptorPoolSizeBuilder<'a> {
13967 #[inline]
13968 pub fn new() -> DescriptorPoolSizeBuilder<'a> {
13969 DescriptorPoolSizeBuilder(Default::default(), std::marker::PhantomData)
13970 }
13971 #[inline]
13972 #[must_use]
13973 pub fn _type(mut self, _type: crate::vk1_0::DescriptorType) -> Self {
13974 self.0._type = _type as _;
13975 self
13976 }
13977 #[inline]
13978 #[must_use]
13979 pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
13980 self.0.descriptor_count = descriptor_count as _;
13981 self
13982 }
13983 #[inline]
13984 pub fn build(self) -> DescriptorPoolSize {
13985 self.0
13986 }
13987}
13988impl<'a> std::default::Default for DescriptorPoolSizeBuilder<'a> {
13989 fn default() -> DescriptorPoolSizeBuilder<'a> {
13990 Self::new()
13991 }
13992}
13993impl<'a> std::fmt::Debug for DescriptorPoolSizeBuilder<'a> {
13994 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
13995 std::fmt::Debug::fmt(&self.0, f)
13996 }
13997}
13998impl<'a> std::ops::Deref for DescriptorPoolSizeBuilder<'a> {
13999 type Target = DescriptorPoolSize;
14000 fn deref(&self) -> &Self::Target {
14001 &self.0
14002 }
14003}
14004impl<'a> std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> {
14005 fn deref_mut(&mut self) -> &mut Self::Target {
14006 &mut self.0
14007 }
14008}
14009#[doc(alias = "VkDescriptorPoolCreateInfo")]
14011#[derive(Copy, Clone)]
14012#[repr(C)]
14013pub struct DescriptorPoolCreateInfo {
14014 pub s_type: crate::vk1_0::StructureType,
14015 pub p_next: *const std::ffi::c_void,
14016 pub flags: crate::vk1_0::DescriptorPoolCreateFlags,
14017 pub max_sets: u32,
14018 pub pool_size_count: u32,
14019 pub p_pool_sizes: *const crate::vk1_0::DescriptorPoolSize,
14020}
14021impl DescriptorPoolCreateInfo {
14022 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::DESCRIPTOR_POOL_CREATE_INFO;
14023}
14024impl Default for DescriptorPoolCreateInfo {
14025 fn default() -> Self {
14026 Self {
14027 s_type: Self::STRUCTURE_TYPE,
14028 p_next: std::ptr::null(),
14029 flags: Default::default(),
14030 max_sets: Default::default(),
14031 pool_size_count: Default::default(),
14032 p_pool_sizes: std::ptr::null(),
14033 }
14034 }
14035}
14036impl std::fmt::Debug for DescriptorPoolCreateInfo {
14037 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14038 f.debug_struct("DescriptorPoolCreateInfo")
14039 .field("s_type", &self.s_type)
14040 .field("p_next", &self.p_next)
14041 .field("flags", &self.flags)
14042 .field("max_sets", &self.max_sets)
14043 .field("pool_size_count", &self.pool_size_count)
14044 .field("p_pool_sizes", &self.p_pool_sizes)
14045 .finish()
14046 }
14047}
14048impl DescriptorPoolCreateInfo {
14049 #[inline]
14050 pub fn into_builder<'a>(self) -> DescriptorPoolCreateInfoBuilder<'a> {
14051 DescriptorPoolCreateInfoBuilder(self, std::marker::PhantomData)
14052 }
14053}
14054#[derive(Copy, Clone)]
14055#[repr(transparent)]
14057pub struct DescriptorPoolCreateInfoBuilder<'a>(
14058 DescriptorPoolCreateInfo,
14059 std::marker::PhantomData<&'a ()>,
14060);
14061impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
14062 #[inline]
14063 pub fn new() -> DescriptorPoolCreateInfoBuilder<'a> {
14064 DescriptorPoolCreateInfoBuilder(Default::default(), std::marker::PhantomData)
14065 }
14066 #[inline]
14067 #[must_use]
14068 pub fn flags(mut self, flags: crate::vk1_0::DescriptorPoolCreateFlags) -> Self {
14069 self.0.flags = flags as _;
14070 self
14071 }
14072 #[inline]
14073 #[must_use]
14074 pub fn max_sets(mut self, max_sets: u32) -> Self {
14075 self.0.max_sets = max_sets as _;
14076 self
14077 }
14078 #[inline]
14079 #[must_use]
14080 pub fn pool_sizes(
14081 mut self,
14082 pool_sizes: &'a [crate::vk1_0::DescriptorPoolSizeBuilder],
14083 ) -> Self {
14084 self.0.p_pool_sizes = pool_sizes.as_ptr() as _;
14085 self.0.pool_size_count = pool_sizes.len() as _;
14086 self
14087 }
14088 #[inline]
14089 pub fn build_dangling(self) -> DescriptorPoolCreateInfo {
14092 self.0
14093 }
14094}
14095impl<'a> std::default::Default for DescriptorPoolCreateInfoBuilder<'a> {
14096 fn default() -> DescriptorPoolCreateInfoBuilder<'a> {
14097 Self::new()
14098 }
14099}
14100impl<'a> std::fmt::Debug for DescriptorPoolCreateInfoBuilder<'a> {
14101 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14102 std::fmt::Debug::fmt(&self.0, f)
14103 }
14104}
14105impl<'a> std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> {
14106 type Target = DescriptorPoolCreateInfo;
14107 fn deref(&self) -> &Self::Target {
14108 &self.0
14109 }
14110}
14111impl<'a> std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> {
14112 fn deref_mut(&mut self) -> &mut Self::Target {
14113 &mut self.0
14114 }
14115}
14116#[doc(alias = "VkDescriptorSetAllocateInfo")]
14118#[derive(Copy, Clone)]
14119#[repr(C)]
14120pub struct DescriptorSetAllocateInfo {
14121 pub s_type: crate::vk1_0::StructureType,
14122 pub p_next: *const std::ffi::c_void,
14123 pub descriptor_pool: crate::vk1_0::DescriptorPool,
14124 pub descriptor_set_count: u32,
14125 pub p_set_layouts: *const crate::vk1_0::DescriptorSetLayout,
14126}
14127impl DescriptorSetAllocateInfo {
14128 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::DESCRIPTOR_SET_ALLOCATE_INFO;
14129}
14130impl Default for DescriptorSetAllocateInfo {
14131 fn default() -> Self {
14132 Self {
14133 s_type: Self::STRUCTURE_TYPE,
14134 p_next: std::ptr::null(),
14135 descriptor_pool: Default::default(),
14136 descriptor_set_count: Default::default(),
14137 p_set_layouts: std::ptr::null(),
14138 }
14139 }
14140}
14141impl std::fmt::Debug for DescriptorSetAllocateInfo {
14142 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14143 f.debug_struct("DescriptorSetAllocateInfo")
14144 .field("s_type", &self.s_type)
14145 .field("p_next", &self.p_next)
14146 .field("descriptor_pool", &self.descriptor_pool)
14147 .field("descriptor_set_count", &self.descriptor_set_count)
14148 .field("p_set_layouts", &self.p_set_layouts)
14149 .finish()
14150 }
14151}
14152impl DescriptorSetAllocateInfo {
14153 #[inline]
14154 pub fn into_builder<'a>(self) -> DescriptorSetAllocateInfoBuilder<'a> {
14155 DescriptorSetAllocateInfoBuilder(self, std::marker::PhantomData)
14156 }
14157}
14158#[derive(Copy, Clone)]
14159#[repr(transparent)]
14161pub struct DescriptorSetAllocateInfoBuilder<'a>(
14162 DescriptorSetAllocateInfo,
14163 std::marker::PhantomData<&'a ()>,
14164);
14165impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
14166 #[inline]
14167 pub fn new() -> DescriptorSetAllocateInfoBuilder<'a> {
14168 DescriptorSetAllocateInfoBuilder(Default::default(), std::marker::PhantomData)
14169 }
14170 #[inline]
14171 #[must_use]
14172 pub fn descriptor_pool(
14173 mut self,
14174 descriptor_pool: crate::vk1_0::DescriptorPool,
14175 ) -> Self {
14176 self.0.descriptor_pool = descriptor_pool as _;
14177 self
14178 }
14179 #[inline]
14180 #[must_use]
14181 pub fn set_layouts(
14182 mut self,
14183 set_layouts: &'a [crate::vk1_0::DescriptorSetLayout],
14184 ) -> Self {
14185 self.0.p_set_layouts = set_layouts.as_ptr() as _;
14186 self.0.descriptor_set_count = set_layouts.len() as _;
14187 self
14188 }
14189 #[inline]
14190 pub fn build_dangling(self) -> DescriptorSetAllocateInfo {
14193 self.0
14194 }
14195}
14196impl<'a> std::default::Default for DescriptorSetAllocateInfoBuilder<'a> {
14197 fn default() -> DescriptorSetAllocateInfoBuilder<'a> {
14198 Self::new()
14199 }
14200}
14201impl<'a> std::fmt::Debug for DescriptorSetAllocateInfoBuilder<'a> {
14202 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14203 std::fmt::Debug::fmt(&self.0, f)
14204 }
14205}
14206impl<'a> std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> {
14207 type Target = DescriptorSetAllocateInfo;
14208 fn deref(&self) -> &Self::Target {
14209 &self.0
14210 }
14211}
14212impl<'a> std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> {
14213 fn deref_mut(&mut self) -> &mut Self::Target {
14214 &mut self.0
14215 }
14216}
14217#[doc(alias = "VkSpecializationMapEntry")]
14219#[derive(Copy, Clone, Hash, PartialEq, Eq)]
14220#[repr(C)]
14221pub struct SpecializationMapEntry {
14222 pub constant_id: u32,
14223 pub offset: u32,
14224 pub size: usize,
14225}
14226impl Default for SpecializationMapEntry {
14227 fn default() -> Self {
14228 Self {
14229 constant_id: Default::default(),
14230 offset: Default::default(),
14231 size: Default::default(),
14232 }
14233 }
14234}
14235impl std::fmt::Debug for SpecializationMapEntry {
14236 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14237 f.debug_struct("SpecializationMapEntry")
14238 .field("constant_id", &self.constant_id)
14239 .field("offset", &self.offset)
14240 .field("size", &self.size)
14241 .finish()
14242 }
14243}
14244impl SpecializationMapEntry {
14245 #[inline]
14246 pub fn into_builder<'a>(self) -> SpecializationMapEntryBuilder<'a> {
14247 SpecializationMapEntryBuilder(self, std::marker::PhantomData)
14248 }
14249}
14250#[derive(Copy, Clone)]
14251#[repr(transparent)]
14253pub struct SpecializationMapEntryBuilder<'a>(
14254 SpecializationMapEntry,
14255 std::marker::PhantomData<&'a ()>,
14256);
14257impl<'a> SpecializationMapEntryBuilder<'a> {
14258 #[inline]
14259 pub fn new() -> SpecializationMapEntryBuilder<'a> {
14260 SpecializationMapEntryBuilder(Default::default(), std::marker::PhantomData)
14261 }
14262 #[inline]
14263 #[must_use]
14264 pub fn constant_id(mut self, constant_id: u32) -> Self {
14265 self.0.constant_id = constant_id as _;
14266 self
14267 }
14268 #[inline]
14269 #[must_use]
14270 pub fn offset(mut self, offset: u32) -> Self {
14271 self.0.offset = offset as _;
14272 self
14273 }
14274 #[inline]
14275 #[must_use]
14276 pub fn size(mut self, size: usize) -> Self {
14277 self.0.size = size as _;
14278 self
14279 }
14280 #[inline]
14281 pub fn build(self) -> SpecializationMapEntry {
14282 self.0
14283 }
14284}
14285impl<'a> std::default::Default for SpecializationMapEntryBuilder<'a> {
14286 fn default() -> SpecializationMapEntryBuilder<'a> {
14287 Self::new()
14288 }
14289}
14290impl<'a> std::fmt::Debug for SpecializationMapEntryBuilder<'a> {
14291 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14292 std::fmt::Debug::fmt(&self.0, f)
14293 }
14294}
14295impl<'a> std::ops::Deref for SpecializationMapEntryBuilder<'a> {
14296 type Target = SpecializationMapEntry;
14297 fn deref(&self) -> &Self::Target {
14298 &self.0
14299 }
14300}
14301impl<'a> std::ops::DerefMut for SpecializationMapEntryBuilder<'a> {
14302 fn deref_mut(&mut self) -> &mut Self::Target {
14303 &mut self.0
14304 }
14305}
14306#[doc(alias = "VkSpecializationInfo")]
14308#[derive(Copy, Clone)]
14309#[repr(C)]
14310pub struct SpecializationInfo {
14311 pub map_entry_count: u32,
14312 pub p_map_entries: *const crate::vk1_0::SpecializationMapEntry,
14313 pub data_size: usize,
14314 pub p_data: *const std::ffi::c_void,
14315}
14316impl Default for SpecializationInfo {
14317 fn default() -> Self {
14318 Self {
14319 map_entry_count: Default::default(),
14320 p_map_entries: std::ptr::null(),
14321 data_size: Default::default(),
14322 p_data: std::ptr::null(),
14323 }
14324 }
14325}
14326impl std::fmt::Debug for SpecializationInfo {
14327 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14328 f.debug_struct("SpecializationInfo")
14329 .field("map_entry_count", &self.map_entry_count)
14330 .field("p_map_entries", &self.p_map_entries)
14331 .field("data_size", &self.data_size)
14332 .field("p_data", &self.p_data)
14333 .finish()
14334 }
14335}
14336impl SpecializationInfo {
14337 #[inline]
14338 pub fn into_builder<'a>(self) -> SpecializationInfoBuilder<'a> {
14339 SpecializationInfoBuilder(self, std::marker::PhantomData)
14340 }
14341}
14342#[derive(Copy, Clone)]
14343#[repr(transparent)]
14345pub struct SpecializationInfoBuilder<'a>(
14346 SpecializationInfo,
14347 std::marker::PhantomData<&'a ()>,
14348);
14349impl<'a> SpecializationInfoBuilder<'a> {
14350 #[inline]
14351 pub fn new() -> SpecializationInfoBuilder<'a> {
14352 SpecializationInfoBuilder(Default::default(), std::marker::PhantomData)
14353 }
14354 #[inline]
14355 #[must_use]
14356 pub fn map_entries(
14357 mut self,
14358 map_entries: &'a [crate::vk1_0::SpecializationMapEntryBuilder],
14359 ) -> Self {
14360 self.0.p_map_entries = map_entries.as_ptr() as _;
14361 self.0.map_entry_count = map_entries.len() as _;
14362 self
14363 }
14364 #[inline]
14365 #[must_use]
14366 pub fn data_size(mut self, data_size: usize) -> Self {
14367 self.0.data_size = data_size;
14368 self
14369 }
14370 #[inline]
14371 #[must_use]
14372 pub fn data(mut self, data: *const std::ffi::c_void) -> Self {
14373 self.0.p_data = data;
14374 self
14375 }
14376 #[inline]
14377 pub fn build_dangling(self) -> SpecializationInfo {
14380 self.0
14381 }
14382}
14383impl<'a> std::default::Default for SpecializationInfoBuilder<'a> {
14384 fn default() -> SpecializationInfoBuilder<'a> {
14385 Self::new()
14386 }
14387}
14388impl<'a> std::fmt::Debug for SpecializationInfoBuilder<'a> {
14389 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14390 std::fmt::Debug::fmt(&self.0, f)
14391 }
14392}
14393impl<'a> std::ops::Deref for SpecializationInfoBuilder<'a> {
14394 type Target = SpecializationInfo;
14395 fn deref(&self) -> &Self::Target {
14396 &self.0
14397 }
14398}
14399impl<'a> std::ops::DerefMut for SpecializationInfoBuilder<'a> {
14400 fn deref_mut(&mut self) -> &mut Self::Target {
14401 &mut self.0
14402 }
14403}
14404#[doc(alias = "VkPipelineShaderStageCreateInfo")]
14406#[derive(Copy, Clone)]
14407#[repr(C)]
14408pub struct PipelineShaderStageCreateInfo {
14409 pub s_type: crate::vk1_0::StructureType,
14410 pub p_next: *const std::ffi::c_void,
14411 pub flags: crate::vk1_0::PipelineShaderStageCreateFlags,
14412 pub stage: crate::vk1_0::ShaderStageFlagBits,
14413 pub module: crate::vk1_0::ShaderModule,
14414 pub p_name: *const std::os::raw::c_char,
14415 pub p_specialization_info: *const crate::vk1_0::SpecializationInfo,
14416}
14417impl PipelineShaderStageCreateInfo {
14418 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO;
14419}
14420impl Default for PipelineShaderStageCreateInfo {
14421 fn default() -> Self {
14422 Self {
14423 s_type: Self::STRUCTURE_TYPE,
14424 p_next: std::ptr::null(),
14425 flags: Default::default(),
14426 stage: Default::default(),
14427 module: Default::default(),
14428 p_name: std::ptr::null(),
14429 p_specialization_info: std::ptr::null(),
14430 }
14431 }
14432}
14433impl std::fmt::Debug for PipelineShaderStageCreateInfo {
14434 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14435 f.debug_struct("PipelineShaderStageCreateInfo")
14436 .field("s_type", &self.s_type)
14437 .field("p_next", &self.p_next)
14438 .field("flags", &self.flags)
14439 .field("stage", &self.stage)
14440 .field("module", &self.module)
14441 .field("p_name", &self.p_name)
14442 .field("p_specialization_info", &self.p_specialization_info)
14443 .finish()
14444 }
14445}
14446impl PipelineShaderStageCreateInfo {
14447 #[inline]
14448 pub fn into_builder<'a>(self) -> PipelineShaderStageCreateInfoBuilder<'a> {
14449 PipelineShaderStageCreateInfoBuilder(self, std::marker::PhantomData)
14450 }
14451}
14452impl<'a> crate::ExtendableFrom<'a, ShaderModuleCreateInfo>
14453for crate::vk1_0::PipelineShaderStageCreateInfoBuilder<'a> {}
14454impl<'a> crate::ExtendableFrom<'a, ShaderModuleCreateInfoBuilder<'_>>
14455for crate::vk1_0::PipelineShaderStageCreateInfoBuilder<'a> {}
14456#[derive(Copy, Clone)]
14457#[repr(transparent)]
14459pub struct PipelineShaderStageCreateInfoBuilder<'a>(
14460 PipelineShaderStageCreateInfo,
14461 std::marker::PhantomData<&'a ()>,
14462);
14463impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
14464 #[inline]
14465 pub fn new() -> PipelineShaderStageCreateInfoBuilder<'a> {
14466 PipelineShaderStageCreateInfoBuilder(
14467 Default::default(),
14468 std::marker::PhantomData,
14469 )
14470 }
14471 #[inline]
14472 #[must_use]
14473 pub fn flags(mut self, flags: crate::vk1_0::PipelineShaderStageCreateFlags) -> Self {
14474 self.0.flags = flags as _;
14475 self
14476 }
14477 #[inline]
14478 #[must_use]
14479 pub fn stage(mut self, stage: crate::vk1_0::ShaderStageFlagBits) -> Self {
14480 self.0.stage = stage as _;
14481 self
14482 }
14483 #[inline]
14484 #[must_use]
14485 pub fn module(mut self, module: crate::vk1_0::ShaderModule) -> Self {
14486 self.0.module = module as _;
14487 self
14488 }
14489 #[inline]
14490 #[must_use]
14491 pub fn name(mut self, name: &'a std::ffi::CStr) -> Self {
14492 self.0.p_name = name.as_ptr();
14493 self
14494 }
14495 #[inline]
14496 #[must_use]
14497 pub fn specialization_info(
14498 mut self,
14499 specialization_info: &'a crate::vk1_0::SpecializationInfo,
14500 ) -> Self {
14501 self.0.p_specialization_info = specialization_info as _;
14502 self
14503 }
14504 #[inline]
14505 pub fn build_dangling(self) -> PipelineShaderStageCreateInfo {
14508 self.0
14509 }
14510}
14511impl<'a> std::default::Default for PipelineShaderStageCreateInfoBuilder<'a> {
14512 fn default() -> PipelineShaderStageCreateInfoBuilder<'a> {
14513 Self::new()
14514 }
14515}
14516impl<'a> std::fmt::Debug for PipelineShaderStageCreateInfoBuilder<'a> {
14517 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14518 std::fmt::Debug::fmt(&self.0, f)
14519 }
14520}
14521impl<'a> std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> {
14522 type Target = PipelineShaderStageCreateInfo;
14523 fn deref(&self) -> &Self::Target {
14524 &self.0
14525 }
14526}
14527impl<'a> std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> {
14528 fn deref_mut(&mut self) -> &mut Self::Target {
14529 &mut self.0
14530 }
14531}
14532#[doc(alias = "VkComputePipelineCreateInfo")]
14534#[derive(Copy, Clone)]
14535#[repr(C)]
14536pub struct ComputePipelineCreateInfo {
14537 pub s_type: crate::vk1_0::StructureType,
14538 pub p_next: *const std::ffi::c_void,
14539 pub flags: crate::vk1_0::PipelineCreateFlags,
14540 pub stage: crate::vk1_0::PipelineShaderStageCreateInfo,
14541 pub layout: crate::vk1_0::PipelineLayout,
14542 pub base_pipeline_handle: crate::vk1_0::Pipeline,
14543 pub base_pipeline_index: i32,
14544}
14545impl ComputePipelineCreateInfo {
14546 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::COMPUTE_PIPELINE_CREATE_INFO;
14547}
14548impl Default for ComputePipelineCreateInfo {
14549 fn default() -> Self {
14550 Self {
14551 s_type: Self::STRUCTURE_TYPE,
14552 p_next: std::ptr::null(),
14553 flags: Default::default(),
14554 stage: Default::default(),
14555 layout: Default::default(),
14556 base_pipeline_handle: Default::default(),
14557 base_pipeline_index: Default::default(),
14558 }
14559 }
14560}
14561impl std::fmt::Debug for ComputePipelineCreateInfo {
14562 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14563 f.debug_struct("ComputePipelineCreateInfo")
14564 .field("s_type", &self.s_type)
14565 .field("p_next", &self.p_next)
14566 .field("flags", &self.flags)
14567 .field("stage", &self.stage)
14568 .field("layout", &self.layout)
14569 .field("base_pipeline_handle", &self.base_pipeline_handle)
14570 .field("base_pipeline_index", &self.base_pipeline_index)
14571 .finish()
14572 }
14573}
14574impl ComputePipelineCreateInfo {
14575 #[inline]
14576 pub fn into_builder<'a>(self) -> ComputePipelineCreateInfoBuilder<'a> {
14577 ComputePipelineCreateInfoBuilder(self, std::marker::PhantomData)
14578 }
14579}
14580#[derive(Copy, Clone)]
14581#[repr(transparent)]
14583pub struct ComputePipelineCreateInfoBuilder<'a>(
14584 ComputePipelineCreateInfo,
14585 std::marker::PhantomData<&'a ()>,
14586);
14587impl<'a> ComputePipelineCreateInfoBuilder<'a> {
14588 #[inline]
14589 pub fn new() -> ComputePipelineCreateInfoBuilder<'a> {
14590 ComputePipelineCreateInfoBuilder(Default::default(), std::marker::PhantomData)
14591 }
14592 #[inline]
14593 #[must_use]
14594 pub fn flags(mut self, flags: crate::vk1_0::PipelineCreateFlags) -> Self {
14595 self.0.flags = flags as _;
14596 self
14597 }
14598 #[inline]
14599 #[must_use]
14600 pub fn stage(mut self, stage: crate::vk1_0::PipelineShaderStageCreateInfo) -> Self {
14601 self.0.stage = stage as _;
14602 self
14603 }
14604 #[inline]
14605 #[must_use]
14606 pub fn layout(mut self, layout: crate::vk1_0::PipelineLayout) -> Self {
14607 self.0.layout = layout as _;
14608 self
14609 }
14610 #[inline]
14611 #[must_use]
14612 pub fn base_pipeline_handle(
14613 mut self,
14614 base_pipeline_handle: crate::vk1_0::Pipeline,
14615 ) -> Self {
14616 self.0.base_pipeline_handle = base_pipeline_handle as _;
14617 self
14618 }
14619 #[inline]
14620 #[must_use]
14621 pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
14622 self.0.base_pipeline_index = base_pipeline_index as _;
14623 self
14624 }
14625 #[inline]
14626 pub fn build_dangling(self) -> ComputePipelineCreateInfo {
14629 self.0
14630 }
14631}
14632impl<'a> std::default::Default for ComputePipelineCreateInfoBuilder<'a> {
14633 fn default() -> ComputePipelineCreateInfoBuilder<'a> {
14634 Self::new()
14635 }
14636}
14637impl<'a> std::fmt::Debug for ComputePipelineCreateInfoBuilder<'a> {
14638 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14639 std::fmt::Debug::fmt(&self.0, f)
14640 }
14641}
14642impl<'a> std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> {
14643 type Target = ComputePipelineCreateInfo;
14644 fn deref(&self) -> &Self::Target {
14645 &self.0
14646 }
14647}
14648impl<'a> std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> {
14649 fn deref_mut(&mut self) -> &mut Self::Target {
14650 &mut self.0
14651 }
14652}
14653#[doc(alias = "VkVertexInputBindingDescription")]
14655#[derive(Copy, Clone, Hash, PartialEq, Eq)]
14656#[repr(C)]
14657pub struct VertexInputBindingDescription {
14658 pub binding: u32,
14659 pub stride: u32,
14660 pub input_rate: crate::vk1_0::VertexInputRate,
14661}
14662impl Default for VertexInputBindingDescription {
14663 fn default() -> Self {
14664 Self {
14665 binding: Default::default(),
14666 stride: Default::default(),
14667 input_rate: Default::default(),
14668 }
14669 }
14670}
14671impl std::fmt::Debug for VertexInputBindingDescription {
14672 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14673 f.debug_struct("VertexInputBindingDescription")
14674 .field("binding", &self.binding)
14675 .field("stride", &self.stride)
14676 .field("input_rate", &self.input_rate)
14677 .finish()
14678 }
14679}
14680impl VertexInputBindingDescription {
14681 #[inline]
14682 pub fn into_builder<'a>(self) -> VertexInputBindingDescriptionBuilder<'a> {
14683 VertexInputBindingDescriptionBuilder(self, std::marker::PhantomData)
14684 }
14685}
14686#[derive(Copy, Clone)]
14687#[repr(transparent)]
14689pub struct VertexInputBindingDescriptionBuilder<'a>(
14690 VertexInputBindingDescription,
14691 std::marker::PhantomData<&'a ()>,
14692);
14693impl<'a> VertexInputBindingDescriptionBuilder<'a> {
14694 #[inline]
14695 pub fn new() -> VertexInputBindingDescriptionBuilder<'a> {
14696 VertexInputBindingDescriptionBuilder(
14697 Default::default(),
14698 std::marker::PhantomData,
14699 )
14700 }
14701 #[inline]
14702 #[must_use]
14703 pub fn binding(mut self, binding: u32) -> Self {
14704 self.0.binding = binding as _;
14705 self
14706 }
14707 #[inline]
14708 #[must_use]
14709 pub fn stride(mut self, stride: u32) -> Self {
14710 self.0.stride = stride as _;
14711 self
14712 }
14713 #[inline]
14714 #[must_use]
14715 pub fn input_rate(mut self, input_rate: crate::vk1_0::VertexInputRate) -> Self {
14716 self.0.input_rate = input_rate as _;
14717 self
14718 }
14719 #[inline]
14720 pub fn build(self) -> VertexInputBindingDescription {
14721 self.0
14722 }
14723}
14724impl<'a> std::default::Default for VertexInputBindingDescriptionBuilder<'a> {
14725 fn default() -> VertexInputBindingDescriptionBuilder<'a> {
14726 Self::new()
14727 }
14728}
14729impl<'a> std::fmt::Debug for VertexInputBindingDescriptionBuilder<'a> {
14730 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14731 std::fmt::Debug::fmt(&self.0, f)
14732 }
14733}
14734impl<'a> std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> {
14735 type Target = VertexInputBindingDescription;
14736 fn deref(&self) -> &Self::Target {
14737 &self.0
14738 }
14739}
14740impl<'a> std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> {
14741 fn deref_mut(&mut self) -> &mut Self::Target {
14742 &mut self.0
14743 }
14744}
14745#[doc(alias = "VkVertexInputAttributeDescription")]
14747#[derive(Copy, Clone, Hash, PartialEq, Eq)]
14748#[repr(C)]
14749pub struct VertexInputAttributeDescription {
14750 pub location: u32,
14751 pub binding: u32,
14752 pub format: crate::vk1_0::Format,
14753 pub offset: u32,
14754}
14755impl Default for VertexInputAttributeDescription {
14756 fn default() -> Self {
14757 Self {
14758 location: Default::default(),
14759 binding: Default::default(),
14760 format: Default::default(),
14761 offset: Default::default(),
14762 }
14763 }
14764}
14765impl std::fmt::Debug for VertexInputAttributeDescription {
14766 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14767 f.debug_struct("VertexInputAttributeDescription")
14768 .field("location", &self.location)
14769 .field("binding", &self.binding)
14770 .field("format", &self.format)
14771 .field("offset", &self.offset)
14772 .finish()
14773 }
14774}
14775impl VertexInputAttributeDescription {
14776 #[inline]
14777 pub fn into_builder<'a>(self) -> VertexInputAttributeDescriptionBuilder<'a> {
14778 VertexInputAttributeDescriptionBuilder(self, std::marker::PhantomData)
14779 }
14780}
14781#[derive(Copy, Clone)]
14782#[repr(transparent)]
14784pub struct VertexInputAttributeDescriptionBuilder<'a>(
14785 VertexInputAttributeDescription,
14786 std::marker::PhantomData<&'a ()>,
14787);
14788impl<'a> VertexInputAttributeDescriptionBuilder<'a> {
14789 #[inline]
14790 pub fn new() -> VertexInputAttributeDescriptionBuilder<'a> {
14791 VertexInputAttributeDescriptionBuilder(
14792 Default::default(),
14793 std::marker::PhantomData,
14794 )
14795 }
14796 #[inline]
14797 #[must_use]
14798 pub fn location(mut self, location: u32) -> Self {
14799 self.0.location = location as _;
14800 self
14801 }
14802 #[inline]
14803 #[must_use]
14804 pub fn binding(mut self, binding: u32) -> Self {
14805 self.0.binding = binding as _;
14806 self
14807 }
14808 #[inline]
14809 #[must_use]
14810 pub fn format(mut self, format: crate::vk1_0::Format) -> Self {
14811 self.0.format = format as _;
14812 self
14813 }
14814 #[inline]
14815 #[must_use]
14816 pub fn offset(mut self, offset: u32) -> Self {
14817 self.0.offset = offset as _;
14818 self
14819 }
14820 #[inline]
14821 pub fn build(self) -> VertexInputAttributeDescription {
14822 self.0
14823 }
14824}
14825impl<'a> std::default::Default for VertexInputAttributeDescriptionBuilder<'a> {
14826 fn default() -> VertexInputAttributeDescriptionBuilder<'a> {
14827 Self::new()
14828 }
14829}
14830impl<'a> std::fmt::Debug for VertexInputAttributeDescriptionBuilder<'a> {
14831 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14832 std::fmt::Debug::fmt(&self.0, f)
14833 }
14834}
14835impl<'a> std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> {
14836 type Target = VertexInputAttributeDescription;
14837 fn deref(&self) -> &Self::Target {
14838 &self.0
14839 }
14840}
14841impl<'a> std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> {
14842 fn deref_mut(&mut self) -> &mut Self::Target {
14843 &mut self.0
14844 }
14845}
14846#[doc(alias = "VkPipelineVertexInputStateCreateInfo")]
14848#[derive(Copy, Clone)]
14849#[repr(C)]
14850pub struct PipelineVertexInputStateCreateInfo {
14851 pub s_type: crate::vk1_0::StructureType,
14852 pub p_next: *const std::ffi::c_void,
14853 pub flags: crate::vk1_0::PipelineVertexInputStateCreateFlags,
14854 pub vertex_binding_description_count: u32,
14855 pub p_vertex_binding_descriptions: *const crate::vk1_0::VertexInputBindingDescription,
14856 pub vertex_attribute_description_count: u32,
14857 pub p_vertex_attribute_descriptions: *const crate::vk1_0::VertexInputAttributeDescription,
14858}
14859impl PipelineVertexInputStateCreateInfo {
14860 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
14861}
14862impl Default for PipelineVertexInputStateCreateInfo {
14863 fn default() -> Self {
14864 Self {
14865 s_type: Self::STRUCTURE_TYPE,
14866 p_next: std::ptr::null(),
14867 flags: Default::default(),
14868 vertex_binding_description_count: Default::default(),
14869 p_vertex_binding_descriptions: std::ptr::null(),
14870 vertex_attribute_description_count: Default::default(),
14871 p_vertex_attribute_descriptions: std::ptr::null(),
14872 }
14873 }
14874}
14875impl std::fmt::Debug for PipelineVertexInputStateCreateInfo {
14876 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14877 f.debug_struct("PipelineVertexInputStateCreateInfo")
14878 .field("s_type", &self.s_type)
14879 .field("p_next", &self.p_next)
14880 .field("flags", &self.flags)
14881 .field(
14882 "vertex_binding_description_count",
14883 &self.vertex_binding_description_count,
14884 )
14885 .field("p_vertex_binding_descriptions", &self.p_vertex_binding_descriptions)
14886 .field(
14887 "vertex_attribute_description_count",
14888 &self.vertex_attribute_description_count,
14889 )
14890 .field(
14891 "p_vertex_attribute_descriptions",
14892 &self.p_vertex_attribute_descriptions,
14893 )
14894 .finish()
14895 }
14896}
14897impl PipelineVertexInputStateCreateInfo {
14898 #[inline]
14899 pub fn into_builder<'a>(self) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
14900 PipelineVertexInputStateCreateInfoBuilder(self, std::marker::PhantomData)
14901 }
14902}
14903#[derive(Copy, Clone)]
14904#[repr(transparent)]
14906pub struct PipelineVertexInputStateCreateInfoBuilder<'a>(
14907 PipelineVertexInputStateCreateInfo,
14908 std::marker::PhantomData<&'a ()>,
14909);
14910impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
14911 #[inline]
14912 pub fn new() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
14913 PipelineVertexInputStateCreateInfoBuilder(
14914 Default::default(),
14915 std::marker::PhantomData,
14916 )
14917 }
14918 #[inline]
14919 #[must_use]
14920 pub fn flags(
14921 mut self,
14922 flags: crate::vk1_0::PipelineVertexInputStateCreateFlags,
14923 ) -> Self {
14924 self.0.flags = flags as _;
14925 self
14926 }
14927 #[inline]
14928 #[must_use]
14929 pub fn vertex_binding_descriptions(
14930 mut self,
14931 vertex_binding_descriptions: &'a [crate::vk1_0::VertexInputBindingDescriptionBuilder],
14932 ) -> Self {
14933 self.0.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr() as _;
14934 self.0.vertex_binding_description_count = vertex_binding_descriptions.len() as _;
14935 self
14936 }
14937 #[inline]
14938 #[must_use]
14939 pub fn vertex_attribute_descriptions(
14940 mut self,
14941 vertex_attribute_descriptions: &'a [crate::vk1_0::VertexInputAttributeDescriptionBuilder],
14942 ) -> Self {
14943 self
14944 .0
14945 .p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr()
14946 as _;
14947 self
14948 .0
14949 .vertex_attribute_description_count = vertex_attribute_descriptions.len()
14950 as _;
14951 self
14952 }
14953 #[inline]
14954 pub fn build_dangling(self) -> PipelineVertexInputStateCreateInfo {
14957 self.0
14958 }
14959}
14960impl<'a> std::default::Default for PipelineVertexInputStateCreateInfoBuilder<'a> {
14961 fn default() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
14962 Self::new()
14963 }
14964}
14965impl<'a> std::fmt::Debug for PipelineVertexInputStateCreateInfoBuilder<'a> {
14966 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14967 std::fmt::Debug::fmt(&self.0, f)
14968 }
14969}
14970impl<'a> std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> {
14971 type Target = PipelineVertexInputStateCreateInfo;
14972 fn deref(&self) -> &Self::Target {
14973 &self.0
14974 }
14975}
14976impl<'a> std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> {
14977 fn deref_mut(&mut self) -> &mut Self::Target {
14978 &mut self.0
14979 }
14980}
14981#[doc(alias = "VkPipelineInputAssemblyStateCreateInfo")]
14983#[derive(Copy, Clone)]
14984#[repr(C)]
14985pub struct PipelineInputAssemblyStateCreateInfo {
14986 pub s_type: crate::vk1_0::StructureType,
14987 pub p_next: *const std::ffi::c_void,
14988 pub flags: crate::vk1_0::PipelineInputAssemblyStateCreateFlags,
14989 pub topology: crate::vk1_0::PrimitiveTopology,
14990 pub primitive_restart_enable: crate::vk1_0::Bool32,
14991}
14992impl PipelineInputAssemblyStateCreateInfo {
14993 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
14994}
14995impl Default for PipelineInputAssemblyStateCreateInfo {
14996 fn default() -> Self {
14997 Self {
14998 s_type: Self::STRUCTURE_TYPE,
14999 p_next: std::ptr::null(),
15000 flags: Default::default(),
15001 topology: Default::default(),
15002 primitive_restart_enable: Default::default(),
15003 }
15004 }
15005}
15006impl std::fmt::Debug for PipelineInputAssemblyStateCreateInfo {
15007 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15008 f.debug_struct("PipelineInputAssemblyStateCreateInfo")
15009 .field("s_type", &self.s_type)
15010 .field("p_next", &self.p_next)
15011 .field("flags", &self.flags)
15012 .field("topology", &self.topology)
15013 .field("primitive_restart_enable", &(self.primitive_restart_enable != 0))
15014 .finish()
15015 }
15016}
15017impl PipelineInputAssemblyStateCreateInfo {
15018 #[inline]
15019 pub fn into_builder<'a>(self) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
15020 PipelineInputAssemblyStateCreateInfoBuilder(self, std::marker::PhantomData)
15021 }
15022}
15023#[derive(Copy, Clone)]
15024#[repr(transparent)]
15026pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a>(
15027 PipelineInputAssemblyStateCreateInfo,
15028 std::marker::PhantomData<&'a ()>,
15029);
15030impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
15031 #[inline]
15032 pub fn new() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
15033 PipelineInputAssemblyStateCreateInfoBuilder(
15034 Default::default(),
15035 std::marker::PhantomData,
15036 )
15037 }
15038 #[inline]
15039 #[must_use]
15040 pub fn flags(
15041 mut self,
15042 flags: crate::vk1_0::PipelineInputAssemblyStateCreateFlags,
15043 ) -> Self {
15044 self.0.flags = flags as _;
15045 self
15046 }
15047 #[inline]
15048 #[must_use]
15049 pub fn topology(mut self, topology: crate::vk1_0::PrimitiveTopology) -> Self {
15050 self.0.topology = topology as _;
15051 self
15052 }
15053 #[inline]
15054 #[must_use]
15055 pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self {
15056 self.0.primitive_restart_enable = primitive_restart_enable as _;
15057 self
15058 }
15059 #[inline]
15060 pub fn build_dangling(self) -> PipelineInputAssemblyStateCreateInfo {
15063 self.0
15064 }
15065}
15066impl<'a> std::default::Default for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
15067 fn default() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
15068 Self::new()
15069 }
15070}
15071impl<'a> std::fmt::Debug for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
15072 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15073 std::fmt::Debug::fmt(&self.0, f)
15074 }
15075}
15076impl<'a> std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
15077 type Target = PipelineInputAssemblyStateCreateInfo;
15078 fn deref(&self) -> &Self::Target {
15079 &self.0
15080 }
15081}
15082impl<'a> std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
15083 fn deref_mut(&mut self) -> &mut Self::Target {
15084 &mut self.0
15085 }
15086}
15087#[doc(alias = "VkPipelineTessellationStateCreateInfo")]
15089#[derive(Copy, Clone)]
15090#[repr(C)]
15091pub struct PipelineTessellationStateCreateInfo {
15092 pub s_type: crate::vk1_0::StructureType,
15093 pub p_next: *const std::ffi::c_void,
15094 pub flags: crate::vk1_0::PipelineTessellationStateCreateFlags,
15095 pub patch_control_points: u32,
15096}
15097impl PipelineTessellationStateCreateInfo {
15098 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO;
15099}
15100impl Default for PipelineTessellationStateCreateInfo {
15101 fn default() -> Self {
15102 Self {
15103 s_type: Self::STRUCTURE_TYPE,
15104 p_next: std::ptr::null(),
15105 flags: Default::default(),
15106 patch_control_points: Default::default(),
15107 }
15108 }
15109}
15110impl std::fmt::Debug for PipelineTessellationStateCreateInfo {
15111 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15112 f.debug_struct("PipelineTessellationStateCreateInfo")
15113 .field("s_type", &self.s_type)
15114 .field("p_next", &self.p_next)
15115 .field("flags", &self.flags)
15116 .field("patch_control_points", &self.patch_control_points)
15117 .finish()
15118 }
15119}
15120impl PipelineTessellationStateCreateInfo {
15121 #[inline]
15122 pub fn into_builder<'a>(self) -> PipelineTessellationStateCreateInfoBuilder<'a> {
15123 PipelineTessellationStateCreateInfoBuilder(self, std::marker::PhantomData)
15124 }
15125}
15126#[derive(Copy, Clone)]
15127#[repr(transparent)]
15129pub struct PipelineTessellationStateCreateInfoBuilder<'a>(
15130 PipelineTessellationStateCreateInfo,
15131 std::marker::PhantomData<&'a ()>,
15132);
15133impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
15134 #[inline]
15135 pub fn new() -> PipelineTessellationStateCreateInfoBuilder<'a> {
15136 PipelineTessellationStateCreateInfoBuilder(
15137 Default::default(),
15138 std::marker::PhantomData,
15139 )
15140 }
15141 #[inline]
15142 #[must_use]
15143 pub fn flags(
15144 mut self,
15145 flags: crate::vk1_0::PipelineTessellationStateCreateFlags,
15146 ) -> Self {
15147 self.0.flags = flags as _;
15148 self
15149 }
15150 #[inline]
15151 #[must_use]
15152 pub fn patch_control_points(mut self, patch_control_points: u32) -> Self {
15153 self.0.patch_control_points = patch_control_points as _;
15154 self
15155 }
15156 #[inline]
15157 pub fn build_dangling(self) -> PipelineTessellationStateCreateInfo {
15160 self.0
15161 }
15162}
15163impl<'a> std::default::Default for PipelineTessellationStateCreateInfoBuilder<'a> {
15164 fn default() -> PipelineTessellationStateCreateInfoBuilder<'a> {
15165 Self::new()
15166 }
15167}
15168impl<'a> std::fmt::Debug for PipelineTessellationStateCreateInfoBuilder<'a> {
15169 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15170 std::fmt::Debug::fmt(&self.0, f)
15171 }
15172}
15173impl<'a> std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> {
15174 type Target = PipelineTessellationStateCreateInfo;
15175 fn deref(&self) -> &Self::Target {
15176 &self.0
15177 }
15178}
15179impl<'a> std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> {
15180 fn deref_mut(&mut self) -> &mut Self::Target {
15181 &mut self.0
15182 }
15183}
15184#[doc(alias = "VkPipelineViewportStateCreateInfo")]
15186#[derive(Copy, Clone)]
15187#[repr(C)]
15188pub struct PipelineViewportStateCreateInfo {
15189 pub s_type: crate::vk1_0::StructureType,
15190 pub p_next: *const std::ffi::c_void,
15191 pub flags: crate::vk1_0::PipelineViewportStateCreateFlags,
15192 pub viewport_count: u32,
15193 pub p_viewports: *const crate::vk1_0::Viewport,
15194 pub scissor_count: u32,
15195 pub p_scissors: *const crate::vk1_0::Rect2D,
15196}
15197impl PipelineViewportStateCreateInfo {
15198 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO;
15199}
15200impl Default for PipelineViewportStateCreateInfo {
15201 fn default() -> Self {
15202 Self {
15203 s_type: Self::STRUCTURE_TYPE,
15204 p_next: std::ptr::null(),
15205 flags: Default::default(),
15206 viewport_count: Default::default(),
15207 p_viewports: std::ptr::null(),
15208 scissor_count: Default::default(),
15209 p_scissors: std::ptr::null(),
15210 }
15211 }
15212}
15213impl std::fmt::Debug for PipelineViewportStateCreateInfo {
15214 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15215 f.debug_struct("PipelineViewportStateCreateInfo")
15216 .field("s_type", &self.s_type)
15217 .field("p_next", &self.p_next)
15218 .field("flags", &self.flags)
15219 .field("viewport_count", &self.viewport_count)
15220 .field("p_viewports", &self.p_viewports)
15221 .field("scissor_count", &self.scissor_count)
15222 .field("p_scissors", &self.p_scissors)
15223 .finish()
15224 }
15225}
15226impl PipelineViewportStateCreateInfo {
15227 #[inline]
15228 pub fn into_builder<'a>(self) -> PipelineViewportStateCreateInfoBuilder<'a> {
15229 PipelineViewportStateCreateInfoBuilder(self, std::marker::PhantomData)
15230 }
15231}
15232#[derive(Copy, Clone)]
15233#[repr(transparent)]
15235pub struct PipelineViewportStateCreateInfoBuilder<'a>(
15236 PipelineViewportStateCreateInfo,
15237 std::marker::PhantomData<&'a ()>,
15238);
15239impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
15240 #[inline]
15241 pub fn new() -> PipelineViewportStateCreateInfoBuilder<'a> {
15242 PipelineViewportStateCreateInfoBuilder(
15243 Default::default(),
15244 std::marker::PhantomData,
15245 )
15246 }
15247 #[inline]
15248 #[must_use]
15249 pub fn flags(
15250 mut self,
15251 flags: crate::vk1_0::PipelineViewportStateCreateFlags,
15252 ) -> Self {
15253 self.0.flags = flags as _;
15254 self
15255 }
15256 #[inline]
15257 #[must_use]
15258 pub fn viewport_count(mut self, viewport_count: u32) -> Self {
15259 self.0.viewport_count = viewport_count as _;
15260 self
15261 }
15262 #[inline]
15263 #[must_use]
15264 pub fn viewports(mut self, viewports: &'a [crate::vk1_0::ViewportBuilder]) -> Self {
15265 self.0.p_viewports = viewports.as_ptr() as _;
15266 self.0.viewport_count = viewports.len() as _;
15267 self
15268 }
15269 #[inline]
15270 #[must_use]
15271 pub fn scissor_count(mut self, scissor_count: u32) -> Self {
15272 self.0.scissor_count = scissor_count as _;
15273 self
15274 }
15275 #[inline]
15276 #[must_use]
15277 pub fn scissors(mut self, scissors: &'a [crate::vk1_0::Rect2DBuilder]) -> Self {
15278 self.0.p_scissors = scissors.as_ptr() as _;
15279 self.0.scissor_count = scissors.len() as _;
15280 self
15281 }
15282 #[inline]
15283 pub fn build_dangling(self) -> PipelineViewportStateCreateInfo {
15286 self.0
15287 }
15288}
15289impl<'a> std::default::Default for PipelineViewportStateCreateInfoBuilder<'a> {
15290 fn default() -> PipelineViewportStateCreateInfoBuilder<'a> {
15291 Self::new()
15292 }
15293}
15294impl<'a> std::fmt::Debug for PipelineViewportStateCreateInfoBuilder<'a> {
15295 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15296 std::fmt::Debug::fmt(&self.0, f)
15297 }
15298}
15299impl<'a> std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> {
15300 type Target = PipelineViewportStateCreateInfo;
15301 fn deref(&self) -> &Self::Target {
15302 &self.0
15303 }
15304}
15305impl<'a> std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> {
15306 fn deref_mut(&mut self) -> &mut Self::Target {
15307 &mut self.0
15308 }
15309}
15310#[doc(alias = "VkPipelineRasterizationStateCreateInfo")]
15312#[derive(Copy, Clone)]
15313#[repr(C)]
15314pub struct PipelineRasterizationStateCreateInfo {
15315 pub s_type: crate::vk1_0::StructureType,
15316 pub p_next: *const std::ffi::c_void,
15317 pub flags: crate::vk1_0::PipelineRasterizationStateCreateFlags,
15318 pub depth_clamp_enable: crate::vk1_0::Bool32,
15319 pub rasterizer_discard_enable: crate::vk1_0::Bool32,
15320 pub polygon_mode: crate::vk1_0::PolygonMode,
15321 pub cull_mode: crate::vk1_0::CullModeFlags,
15322 pub front_face: crate::vk1_0::FrontFace,
15323 pub depth_bias_enable: crate::vk1_0::Bool32,
15324 pub depth_bias_constant_factor: std::os::raw::c_float,
15325 pub depth_bias_clamp: std::os::raw::c_float,
15326 pub depth_bias_slope_factor: std::os::raw::c_float,
15327 pub line_width: std::os::raw::c_float,
15328}
15329impl PipelineRasterizationStateCreateInfo {
15330 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
15331}
15332impl Default for PipelineRasterizationStateCreateInfo {
15333 fn default() -> Self {
15334 Self {
15335 s_type: Self::STRUCTURE_TYPE,
15336 p_next: std::ptr::null(),
15337 flags: Default::default(),
15338 depth_clamp_enable: Default::default(),
15339 rasterizer_discard_enable: Default::default(),
15340 polygon_mode: Default::default(),
15341 cull_mode: Default::default(),
15342 front_face: Default::default(),
15343 depth_bias_enable: Default::default(),
15344 depth_bias_constant_factor: Default::default(),
15345 depth_bias_clamp: Default::default(),
15346 depth_bias_slope_factor: Default::default(),
15347 line_width: Default::default(),
15348 }
15349 }
15350}
15351impl std::fmt::Debug for PipelineRasterizationStateCreateInfo {
15352 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15353 f.debug_struct("PipelineRasterizationStateCreateInfo")
15354 .field("s_type", &self.s_type)
15355 .field("p_next", &self.p_next)
15356 .field("flags", &self.flags)
15357 .field("depth_clamp_enable", &(self.depth_clamp_enable != 0))
15358 .field("rasterizer_discard_enable", &(self.rasterizer_discard_enable != 0))
15359 .field("polygon_mode", &self.polygon_mode)
15360 .field("cull_mode", &self.cull_mode)
15361 .field("front_face", &self.front_face)
15362 .field("depth_bias_enable", &(self.depth_bias_enable != 0))
15363 .field("depth_bias_constant_factor", &self.depth_bias_constant_factor)
15364 .field("depth_bias_clamp", &self.depth_bias_clamp)
15365 .field("depth_bias_slope_factor", &self.depth_bias_slope_factor)
15366 .field("line_width", &self.line_width)
15367 .finish()
15368 }
15369}
15370impl PipelineRasterizationStateCreateInfo {
15371 #[inline]
15372 pub fn into_builder<'a>(self) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
15373 PipelineRasterizationStateCreateInfoBuilder(self, std::marker::PhantomData)
15374 }
15375}
15376#[derive(Copy, Clone)]
15377#[repr(transparent)]
15379pub struct PipelineRasterizationStateCreateInfoBuilder<'a>(
15380 PipelineRasterizationStateCreateInfo,
15381 std::marker::PhantomData<&'a ()>,
15382);
15383impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
15384 #[inline]
15385 pub fn new() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
15386 PipelineRasterizationStateCreateInfoBuilder(
15387 Default::default(),
15388 std::marker::PhantomData,
15389 )
15390 }
15391 #[inline]
15392 #[must_use]
15393 pub fn flags(
15394 mut self,
15395 flags: crate::vk1_0::PipelineRasterizationStateCreateFlags,
15396 ) -> Self {
15397 self.0.flags = flags as _;
15398 self
15399 }
15400 #[inline]
15401 #[must_use]
15402 pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self {
15403 self.0.depth_clamp_enable = depth_clamp_enable as _;
15404 self
15405 }
15406 #[inline]
15407 #[must_use]
15408 pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self {
15409 self.0.rasterizer_discard_enable = rasterizer_discard_enable as _;
15410 self
15411 }
15412 #[inline]
15413 #[must_use]
15414 pub fn polygon_mode(mut self, polygon_mode: crate::vk1_0::PolygonMode) -> Self {
15415 self.0.polygon_mode = polygon_mode as _;
15416 self
15417 }
15418 #[inline]
15419 #[must_use]
15420 pub fn cull_mode(mut self, cull_mode: crate::vk1_0::CullModeFlags) -> Self {
15421 self.0.cull_mode = cull_mode as _;
15422 self
15423 }
15424 #[inline]
15425 #[must_use]
15426 pub fn front_face(mut self, front_face: crate::vk1_0::FrontFace) -> Self {
15427 self.0.front_face = front_face as _;
15428 self
15429 }
15430 #[inline]
15431 #[must_use]
15432 pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self {
15433 self.0.depth_bias_enable = depth_bias_enable as _;
15434 self
15435 }
15436 #[inline]
15437 #[must_use]
15438 pub fn depth_bias_constant_factor(
15439 mut self,
15440 depth_bias_constant_factor: std::os::raw::c_float,
15441 ) -> Self {
15442 self.0.depth_bias_constant_factor = depth_bias_constant_factor as _;
15443 self
15444 }
15445 #[inline]
15446 #[must_use]
15447 pub fn depth_bias_clamp(mut self, depth_bias_clamp: std::os::raw::c_float) -> Self {
15448 self.0.depth_bias_clamp = depth_bias_clamp as _;
15449 self
15450 }
15451 #[inline]
15452 #[must_use]
15453 pub fn depth_bias_slope_factor(
15454 mut self,
15455 depth_bias_slope_factor: std::os::raw::c_float,
15456 ) -> Self {
15457 self.0.depth_bias_slope_factor = depth_bias_slope_factor as _;
15458 self
15459 }
15460 #[inline]
15461 #[must_use]
15462 pub fn line_width(mut self, line_width: std::os::raw::c_float) -> Self {
15463 self.0.line_width = line_width as _;
15464 self
15465 }
15466 #[inline]
15467 pub fn build_dangling(self) -> PipelineRasterizationStateCreateInfo {
15470 self.0
15471 }
15472}
15473impl<'a> std::default::Default for PipelineRasterizationStateCreateInfoBuilder<'a> {
15474 fn default() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
15475 Self::new()
15476 }
15477}
15478impl<'a> std::fmt::Debug for PipelineRasterizationStateCreateInfoBuilder<'a> {
15479 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15480 std::fmt::Debug::fmt(&self.0, f)
15481 }
15482}
15483impl<'a> std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> {
15484 type Target = PipelineRasterizationStateCreateInfo;
15485 fn deref(&self) -> &Self::Target {
15486 &self.0
15487 }
15488}
15489impl<'a> std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> {
15490 fn deref_mut(&mut self) -> &mut Self::Target {
15491 &mut self.0
15492 }
15493}
15494#[doc(alias = "VkPipelineMultisampleStateCreateInfo")]
15496#[derive(Copy, Clone)]
15497#[repr(C)]
15498pub struct PipelineMultisampleStateCreateInfo {
15499 pub s_type: crate::vk1_0::StructureType,
15500 pub p_next: *const std::ffi::c_void,
15501 pub flags: crate::vk1_0::PipelineMultisampleStateCreateFlags,
15502 pub rasterization_samples: crate::vk1_0::SampleCountFlagBits,
15503 pub sample_shading_enable: crate::vk1_0::Bool32,
15504 pub min_sample_shading: std::os::raw::c_float,
15505 pub p_sample_mask: *const crate::vk1_0::SampleMask,
15506 pub alpha_to_coverage_enable: crate::vk1_0::Bool32,
15507 pub alpha_to_one_enable: crate::vk1_0::Bool32,
15508}
15509impl PipelineMultisampleStateCreateInfo {
15510 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
15511}
15512impl Default for PipelineMultisampleStateCreateInfo {
15513 fn default() -> Self {
15514 Self {
15515 s_type: Self::STRUCTURE_TYPE,
15516 p_next: std::ptr::null(),
15517 flags: Default::default(),
15518 rasterization_samples: Default::default(),
15519 sample_shading_enable: Default::default(),
15520 min_sample_shading: Default::default(),
15521 p_sample_mask: std::ptr::null(),
15522 alpha_to_coverage_enable: Default::default(),
15523 alpha_to_one_enable: Default::default(),
15524 }
15525 }
15526}
15527impl std::fmt::Debug for PipelineMultisampleStateCreateInfo {
15528 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15529 f.debug_struct("PipelineMultisampleStateCreateInfo")
15530 .field("s_type", &self.s_type)
15531 .field("p_next", &self.p_next)
15532 .field("flags", &self.flags)
15533 .field("rasterization_samples", &self.rasterization_samples)
15534 .field("sample_shading_enable", &(self.sample_shading_enable != 0))
15535 .field("min_sample_shading", &self.min_sample_shading)
15536 .field("p_sample_mask", &self.p_sample_mask)
15537 .field("alpha_to_coverage_enable", &(self.alpha_to_coverage_enable != 0))
15538 .field("alpha_to_one_enable", &(self.alpha_to_one_enable != 0))
15539 .finish()
15540 }
15541}
15542impl PipelineMultisampleStateCreateInfo {
15543 #[inline]
15544 pub fn into_builder<'a>(self) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
15545 PipelineMultisampleStateCreateInfoBuilder(self, std::marker::PhantomData)
15546 }
15547}
15548#[derive(Copy, Clone)]
15549#[repr(transparent)]
15551pub struct PipelineMultisampleStateCreateInfoBuilder<'a>(
15552 PipelineMultisampleStateCreateInfo,
15553 std::marker::PhantomData<&'a ()>,
15554);
15555impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
15556 #[inline]
15557 pub fn new() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
15558 PipelineMultisampleStateCreateInfoBuilder(
15559 Default::default(),
15560 std::marker::PhantomData,
15561 )
15562 }
15563 #[inline]
15564 #[must_use]
15565 pub fn flags(
15566 mut self,
15567 flags: crate::vk1_0::PipelineMultisampleStateCreateFlags,
15568 ) -> Self {
15569 self.0.flags = flags as _;
15570 self
15571 }
15572 #[inline]
15573 #[must_use]
15574 pub fn rasterization_samples(
15575 mut self,
15576 rasterization_samples: crate::vk1_0::SampleCountFlagBits,
15577 ) -> Self {
15578 self.0.rasterization_samples = rasterization_samples as _;
15579 self
15580 }
15581 #[inline]
15582 #[must_use]
15583 pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self {
15584 self.0.sample_shading_enable = sample_shading_enable as _;
15585 self
15586 }
15587 #[inline]
15588 #[must_use]
15589 pub fn min_sample_shading(
15590 mut self,
15591 min_sample_shading: std::os::raw::c_float,
15592 ) -> Self {
15593 self.0.min_sample_shading = min_sample_shading as _;
15594 self
15595 }
15596 #[inline]
15597 #[must_use]
15598 pub fn sample_mask(mut self, sample_mask: &'a [crate::vk1_0::SampleMask]) -> Self {
15599 self
15600 .0
15601 .p_sample_mask = if sample_mask.is_empty() {
15602 std::ptr::null()
15603 } else {
15604 sample_mask.as_ptr() as _
15605 };
15606 self
15607 }
15608 #[inline]
15609 #[must_use]
15610 pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self {
15611 self.0.alpha_to_coverage_enable = alpha_to_coverage_enable as _;
15612 self
15613 }
15614 #[inline]
15615 #[must_use]
15616 pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self {
15617 self.0.alpha_to_one_enable = alpha_to_one_enable as _;
15618 self
15619 }
15620 #[inline]
15621 pub fn build_dangling(self) -> PipelineMultisampleStateCreateInfo {
15624 self.0
15625 }
15626}
15627impl<'a> std::default::Default for PipelineMultisampleStateCreateInfoBuilder<'a> {
15628 fn default() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
15629 Self::new()
15630 }
15631}
15632impl<'a> std::fmt::Debug for PipelineMultisampleStateCreateInfoBuilder<'a> {
15633 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15634 std::fmt::Debug::fmt(&self.0, f)
15635 }
15636}
15637impl<'a> std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> {
15638 type Target = PipelineMultisampleStateCreateInfo;
15639 fn deref(&self) -> &Self::Target {
15640 &self.0
15641 }
15642}
15643impl<'a> std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> {
15644 fn deref_mut(&mut self) -> &mut Self::Target {
15645 &mut self.0
15646 }
15647}
15648#[doc(alias = "VkPipelineColorBlendAttachmentState")]
15650#[derive(Copy, Clone, Hash, PartialEq, Eq)]
15651#[repr(C)]
15652pub struct PipelineColorBlendAttachmentState {
15653 pub blend_enable: crate::vk1_0::Bool32,
15654 pub src_color_blend_factor: crate::vk1_0::BlendFactor,
15655 pub dst_color_blend_factor: crate::vk1_0::BlendFactor,
15656 pub color_blend_op: crate::vk1_0::BlendOp,
15657 pub src_alpha_blend_factor: crate::vk1_0::BlendFactor,
15658 pub dst_alpha_blend_factor: crate::vk1_0::BlendFactor,
15659 pub alpha_blend_op: crate::vk1_0::BlendOp,
15660 pub color_write_mask: crate::vk1_0::ColorComponentFlags,
15661}
15662impl Default for PipelineColorBlendAttachmentState {
15663 fn default() -> Self {
15664 Self {
15665 blend_enable: Default::default(),
15666 src_color_blend_factor: Default::default(),
15667 dst_color_blend_factor: Default::default(),
15668 color_blend_op: Default::default(),
15669 src_alpha_blend_factor: Default::default(),
15670 dst_alpha_blend_factor: Default::default(),
15671 alpha_blend_op: Default::default(),
15672 color_write_mask: Default::default(),
15673 }
15674 }
15675}
15676impl std::fmt::Debug for PipelineColorBlendAttachmentState {
15677 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15678 f.debug_struct("PipelineColorBlendAttachmentState")
15679 .field("blend_enable", &(self.blend_enable != 0))
15680 .field("src_color_blend_factor", &self.src_color_blend_factor)
15681 .field("dst_color_blend_factor", &self.dst_color_blend_factor)
15682 .field("color_blend_op", &self.color_blend_op)
15683 .field("src_alpha_blend_factor", &self.src_alpha_blend_factor)
15684 .field("dst_alpha_blend_factor", &self.dst_alpha_blend_factor)
15685 .field("alpha_blend_op", &self.alpha_blend_op)
15686 .field("color_write_mask", &self.color_write_mask)
15687 .finish()
15688 }
15689}
15690impl PipelineColorBlendAttachmentState {
15691 #[inline]
15692 pub fn into_builder<'a>(self) -> PipelineColorBlendAttachmentStateBuilder<'a> {
15693 PipelineColorBlendAttachmentStateBuilder(self, std::marker::PhantomData)
15694 }
15695}
15696#[derive(Copy, Clone)]
15697#[repr(transparent)]
15699pub struct PipelineColorBlendAttachmentStateBuilder<'a>(
15700 PipelineColorBlendAttachmentState,
15701 std::marker::PhantomData<&'a ()>,
15702);
15703impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> {
15704 #[inline]
15705 pub fn new() -> PipelineColorBlendAttachmentStateBuilder<'a> {
15706 PipelineColorBlendAttachmentStateBuilder(
15707 Default::default(),
15708 std::marker::PhantomData,
15709 )
15710 }
15711 #[inline]
15712 #[must_use]
15713 pub fn blend_enable(mut self, blend_enable: bool) -> Self {
15714 self.0.blend_enable = blend_enable as _;
15715 self
15716 }
15717 #[inline]
15718 #[must_use]
15719 pub fn src_color_blend_factor(
15720 mut self,
15721 src_color_blend_factor: crate::vk1_0::BlendFactor,
15722 ) -> Self {
15723 self.0.src_color_blend_factor = src_color_blend_factor as _;
15724 self
15725 }
15726 #[inline]
15727 #[must_use]
15728 pub fn dst_color_blend_factor(
15729 mut self,
15730 dst_color_blend_factor: crate::vk1_0::BlendFactor,
15731 ) -> Self {
15732 self.0.dst_color_blend_factor = dst_color_blend_factor as _;
15733 self
15734 }
15735 #[inline]
15736 #[must_use]
15737 pub fn color_blend_op(mut self, color_blend_op: crate::vk1_0::BlendOp) -> Self {
15738 self.0.color_blend_op = color_blend_op as _;
15739 self
15740 }
15741 #[inline]
15742 #[must_use]
15743 pub fn src_alpha_blend_factor(
15744 mut self,
15745 src_alpha_blend_factor: crate::vk1_0::BlendFactor,
15746 ) -> Self {
15747 self.0.src_alpha_blend_factor = src_alpha_blend_factor as _;
15748 self
15749 }
15750 #[inline]
15751 #[must_use]
15752 pub fn dst_alpha_blend_factor(
15753 mut self,
15754 dst_alpha_blend_factor: crate::vk1_0::BlendFactor,
15755 ) -> Self {
15756 self.0.dst_alpha_blend_factor = dst_alpha_blend_factor as _;
15757 self
15758 }
15759 #[inline]
15760 #[must_use]
15761 pub fn alpha_blend_op(mut self, alpha_blend_op: crate::vk1_0::BlendOp) -> Self {
15762 self.0.alpha_blend_op = alpha_blend_op as _;
15763 self
15764 }
15765 #[inline]
15766 #[must_use]
15767 pub fn color_write_mask(
15768 mut self,
15769 color_write_mask: crate::vk1_0::ColorComponentFlags,
15770 ) -> Self {
15771 self.0.color_write_mask = color_write_mask as _;
15772 self
15773 }
15774 #[inline]
15775 pub fn build(self) -> PipelineColorBlendAttachmentState {
15776 self.0
15777 }
15778}
15779impl<'a> std::default::Default for PipelineColorBlendAttachmentStateBuilder<'a> {
15780 fn default() -> PipelineColorBlendAttachmentStateBuilder<'a> {
15781 Self::new()
15782 }
15783}
15784impl<'a> std::fmt::Debug for PipelineColorBlendAttachmentStateBuilder<'a> {
15785 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15786 std::fmt::Debug::fmt(&self.0, f)
15787 }
15788}
15789impl<'a> std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> {
15790 type Target = PipelineColorBlendAttachmentState;
15791 fn deref(&self) -> &Self::Target {
15792 &self.0
15793 }
15794}
15795impl<'a> std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> {
15796 fn deref_mut(&mut self) -> &mut Self::Target {
15797 &mut self.0
15798 }
15799}
15800#[doc(alias = "VkPipelineColorBlendStateCreateInfo")]
15802#[derive(Copy, Clone)]
15803#[repr(C)]
15804pub struct PipelineColorBlendStateCreateInfo {
15805 pub s_type: crate::vk1_0::StructureType,
15806 pub p_next: *const std::ffi::c_void,
15807 pub flags: crate::vk1_0::PipelineColorBlendStateCreateFlags,
15808 pub logic_op_enable: crate::vk1_0::Bool32,
15809 pub logic_op: crate::vk1_0::LogicOp,
15810 pub attachment_count: u32,
15811 pub p_attachments: *const crate::vk1_0::PipelineColorBlendAttachmentState,
15812 pub blend_constants: [std::os::raw::c_float; 4],
15813}
15814impl PipelineColorBlendStateCreateInfo {
15815 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
15816}
15817impl Default for PipelineColorBlendStateCreateInfo {
15818 fn default() -> Self {
15819 Self {
15820 s_type: Self::STRUCTURE_TYPE,
15821 p_next: std::ptr::null(),
15822 flags: Default::default(),
15823 logic_op_enable: Default::default(),
15824 logic_op: Default::default(),
15825 attachment_count: Default::default(),
15826 p_attachments: std::ptr::null(),
15827 blend_constants: unsafe { std::mem::zeroed() },
15828 }
15829 }
15830}
15831impl std::fmt::Debug for PipelineColorBlendStateCreateInfo {
15832 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15833 f.debug_struct("PipelineColorBlendStateCreateInfo")
15834 .field("s_type", &self.s_type)
15835 .field("p_next", &self.p_next)
15836 .field("flags", &self.flags)
15837 .field("logic_op_enable", &(self.logic_op_enable != 0))
15838 .field("logic_op", &self.logic_op)
15839 .field("attachment_count", &self.attachment_count)
15840 .field("p_attachments", &self.p_attachments)
15841 .field("blend_constants", &self.blend_constants)
15842 .finish()
15843 }
15844}
15845impl PipelineColorBlendStateCreateInfo {
15846 #[inline]
15847 pub fn into_builder<'a>(self) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
15848 PipelineColorBlendStateCreateInfoBuilder(self, std::marker::PhantomData)
15849 }
15850}
15851#[derive(Copy, Clone)]
15852#[repr(transparent)]
15854pub struct PipelineColorBlendStateCreateInfoBuilder<'a>(
15855 PipelineColorBlendStateCreateInfo,
15856 std::marker::PhantomData<&'a ()>,
15857);
15858impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
15859 #[inline]
15860 pub fn new() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
15861 PipelineColorBlendStateCreateInfoBuilder(
15862 Default::default(),
15863 std::marker::PhantomData,
15864 )
15865 }
15866 #[inline]
15867 #[must_use]
15868 pub fn flags(
15869 mut self,
15870 flags: crate::vk1_0::PipelineColorBlendStateCreateFlags,
15871 ) -> Self {
15872 self.0.flags = flags as _;
15873 self
15874 }
15875 #[inline]
15876 #[must_use]
15877 pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self {
15878 self.0.logic_op_enable = logic_op_enable as _;
15879 self
15880 }
15881 #[inline]
15882 #[must_use]
15883 pub fn logic_op(mut self, logic_op: crate::vk1_0::LogicOp) -> Self {
15884 self.0.logic_op = logic_op as _;
15885 self
15886 }
15887 #[inline]
15888 #[must_use]
15889 pub fn attachments(
15890 mut self,
15891 attachments: &'a [crate::vk1_0::PipelineColorBlendAttachmentStateBuilder],
15892 ) -> Self {
15893 self.0.p_attachments = attachments.as_ptr() as _;
15894 self.0.attachment_count = attachments.len() as _;
15895 self
15896 }
15897 #[inline]
15898 #[must_use]
15899 pub fn blend_constants(
15900 mut self,
15901 blend_constants: [std::os::raw::c_float; 4],
15902 ) -> Self {
15903 self.0.blend_constants = blend_constants as _;
15904 self
15905 }
15906 #[inline]
15907 pub fn build_dangling(self) -> PipelineColorBlendStateCreateInfo {
15910 self.0
15911 }
15912}
15913impl<'a> std::default::Default for PipelineColorBlendStateCreateInfoBuilder<'a> {
15914 fn default() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
15915 Self::new()
15916 }
15917}
15918impl<'a> std::fmt::Debug for PipelineColorBlendStateCreateInfoBuilder<'a> {
15919 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15920 std::fmt::Debug::fmt(&self.0, f)
15921 }
15922}
15923impl<'a> std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> {
15924 type Target = PipelineColorBlendStateCreateInfo;
15925 fn deref(&self) -> &Self::Target {
15926 &self.0
15927 }
15928}
15929impl<'a> std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> {
15930 fn deref_mut(&mut self) -> &mut Self::Target {
15931 &mut self.0
15932 }
15933}
15934#[doc(alias = "VkPipelineDynamicStateCreateInfo")]
15936#[derive(Copy, Clone)]
15937#[repr(C)]
15938pub struct PipelineDynamicStateCreateInfo {
15939 pub s_type: crate::vk1_0::StructureType,
15940 pub p_next: *const std::ffi::c_void,
15941 pub flags: crate::vk1_0::PipelineDynamicStateCreateFlags,
15942 pub dynamic_state_count: u32,
15943 pub p_dynamic_states: *const crate::vk1_0::DynamicState,
15944}
15945impl PipelineDynamicStateCreateInfo {
15946 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO;
15947}
15948impl Default for PipelineDynamicStateCreateInfo {
15949 fn default() -> Self {
15950 Self {
15951 s_type: Self::STRUCTURE_TYPE,
15952 p_next: std::ptr::null(),
15953 flags: Default::default(),
15954 dynamic_state_count: Default::default(),
15955 p_dynamic_states: std::ptr::null(),
15956 }
15957 }
15958}
15959impl std::fmt::Debug for PipelineDynamicStateCreateInfo {
15960 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
15961 f.debug_struct("PipelineDynamicStateCreateInfo")
15962 .field("s_type", &self.s_type)
15963 .field("p_next", &self.p_next)
15964 .field("flags", &self.flags)
15965 .field("dynamic_state_count", &self.dynamic_state_count)
15966 .field("p_dynamic_states", &self.p_dynamic_states)
15967 .finish()
15968 }
15969}
15970impl PipelineDynamicStateCreateInfo {
15971 #[inline]
15972 pub fn into_builder<'a>(self) -> PipelineDynamicStateCreateInfoBuilder<'a> {
15973 PipelineDynamicStateCreateInfoBuilder(self, std::marker::PhantomData)
15974 }
15975}
15976#[derive(Copy, Clone)]
15977#[repr(transparent)]
15979pub struct PipelineDynamicStateCreateInfoBuilder<'a>(
15980 PipelineDynamicStateCreateInfo,
15981 std::marker::PhantomData<&'a ()>,
15982);
15983impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
15984 #[inline]
15985 pub fn new() -> PipelineDynamicStateCreateInfoBuilder<'a> {
15986 PipelineDynamicStateCreateInfoBuilder(
15987 Default::default(),
15988 std::marker::PhantomData,
15989 )
15990 }
15991 #[inline]
15992 #[must_use]
15993 pub fn flags(
15994 mut self,
15995 flags: crate::vk1_0::PipelineDynamicStateCreateFlags,
15996 ) -> Self {
15997 self.0.flags = flags as _;
15998 self
15999 }
16000 #[inline]
16001 #[must_use]
16002 pub fn dynamic_states(
16003 mut self,
16004 dynamic_states: &'a [crate::vk1_0::DynamicState],
16005 ) -> Self {
16006 self.0.p_dynamic_states = dynamic_states.as_ptr() as _;
16007 self.0.dynamic_state_count = dynamic_states.len() as _;
16008 self
16009 }
16010 #[inline]
16011 pub fn build_dangling(self) -> PipelineDynamicStateCreateInfo {
16014 self.0
16015 }
16016}
16017impl<'a> std::default::Default for PipelineDynamicStateCreateInfoBuilder<'a> {
16018 fn default() -> PipelineDynamicStateCreateInfoBuilder<'a> {
16019 Self::new()
16020 }
16021}
16022impl<'a> std::fmt::Debug for PipelineDynamicStateCreateInfoBuilder<'a> {
16023 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16024 std::fmt::Debug::fmt(&self.0, f)
16025 }
16026}
16027impl<'a> std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> {
16028 type Target = PipelineDynamicStateCreateInfo;
16029 fn deref(&self) -> &Self::Target {
16030 &self.0
16031 }
16032}
16033impl<'a> std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> {
16034 fn deref_mut(&mut self) -> &mut Self::Target {
16035 &mut self.0
16036 }
16037}
16038#[doc(alias = "VkStencilOpState")]
16040#[derive(Copy, Clone, Hash, PartialEq, Eq)]
16041#[repr(C)]
16042pub struct StencilOpState {
16043 pub fail_op: crate::vk1_0::StencilOp,
16044 pub pass_op: crate::vk1_0::StencilOp,
16045 pub depth_fail_op: crate::vk1_0::StencilOp,
16046 pub compare_op: crate::vk1_0::CompareOp,
16047 pub compare_mask: u32,
16048 pub write_mask: u32,
16049 pub reference: u32,
16050}
16051impl Default for StencilOpState {
16052 fn default() -> Self {
16053 Self {
16054 fail_op: Default::default(),
16055 pass_op: Default::default(),
16056 depth_fail_op: Default::default(),
16057 compare_op: Default::default(),
16058 compare_mask: Default::default(),
16059 write_mask: Default::default(),
16060 reference: Default::default(),
16061 }
16062 }
16063}
16064impl std::fmt::Debug for StencilOpState {
16065 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16066 f.debug_struct("StencilOpState")
16067 .field("fail_op", &self.fail_op)
16068 .field("pass_op", &self.pass_op)
16069 .field("depth_fail_op", &self.depth_fail_op)
16070 .field("compare_op", &self.compare_op)
16071 .field("compare_mask", &self.compare_mask)
16072 .field("write_mask", &self.write_mask)
16073 .field("reference", &self.reference)
16074 .finish()
16075 }
16076}
16077impl StencilOpState {
16078 #[inline]
16079 pub fn into_builder<'a>(self) -> StencilOpStateBuilder<'a> {
16080 StencilOpStateBuilder(self, std::marker::PhantomData)
16081 }
16082}
16083#[derive(Copy, Clone)]
16084#[repr(transparent)]
16086pub struct StencilOpStateBuilder<'a>(StencilOpState, std::marker::PhantomData<&'a ()>);
16087impl<'a> StencilOpStateBuilder<'a> {
16088 #[inline]
16089 pub fn new() -> StencilOpStateBuilder<'a> {
16090 StencilOpStateBuilder(Default::default(), std::marker::PhantomData)
16091 }
16092 #[inline]
16093 #[must_use]
16094 pub fn fail_op(mut self, fail_op: crate::vk1_0::StencilOp) -> Self {
16095 self.0.fail_op = fail_op as _;
16096 self
16097 }
16098 #[inline]
16099 #[must_use]
16100 pub fn pass_op(mut self, pass_op: crate::vk1_0::StencilOp) -> Self {
16101 self.0.pass_op = pass_op as _;
16102 self
16103 }
16104 #[inline]
16105 #[must_use]
16106 pub fn depth_fail_op(mut self, depth_fail_op: crate::vk1_0::StencilOp) -> Self {
16107 self.0.depth_fail_op = depth_fail_op as _;
16108 self
16109 }
16110 #[inline]
16111 #[must_use]
16112 pub fn compare_op(mut self, compare_op: crate::vk1_0::CompareOp) -> Self {
16113 self.0.compare_op = compare_op as _;
16114 self
16115 }
16116 #[inline]
16117 #[must_use]
16118 pub fn compare_mask(mut self, compare_mask: u32) -> Self {
16119 self.0.compare_mask = compare_mask as _;
16120 self
16121 }
16122 #[inline]
16123 #[must_use]
16124 pub fn write_mask(mut self, write_mask: u32) -> Self {
16125 self.0.write_mask = write_mask as _;
16126 self
16127 }
16128 #[inline]
16129 #[must_use]
16130 pub fn reference(mut self, reference: u32) -> Self {
16131 self.0.reference = reference as _;
16132 self
16133 }
16134 #[inline]
16135 pub fn build(self) -> StencilOpState {
16136 self.0
16137 }
16138}
16139impl<'a> std::default::Default for StencilOpStateBuilder<'a> {
16140 fn default() -> StencilOpStateBuilder<'a> {
16141 Self::new()
16142 }
16143}
16144impl<'a> std::fmt::Debug for StencilOpStateBuilder<'a> {
16145 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16146 std::fmt::Debug::fmt(&self.0, f)
16147 }
16148}
16149impl<'a> std::ops::Deref for StencilOpStateBuilder<'a> {
16150 type Target = StencilOpState;
16151 fn deref(&self) -> &Self::Target {
16152 &self.0
16153 }
16154}
16155impl<'a> std::ops::DerefMut for StencilOpStateBuilder<'a> {
16156 fn deref_mut(&mut self) -> &mut Self::Target {
16157 &mut self.0
16158 }
16159}
16160#[doc(alias = "VkPipelineDepthStencilStateCreateInfo")]
16162#[derive(Copy, Clone)]
16163#[repr(C)]
16164pub struct PipelineDepthStencilStateCreateInfo {
16165 pub s_type: crate::vk1_0::StructureType,
16166 pub p_next: *const std::ffi::c_void,
16167 pub flags: crate::vk1_0::PipelineDepthStencilStateCreateFlags,
16168 pub depth_test_enable: crate::vk1_0::Bool32,
16169 pub depth_write_enable: crate::vk1_0::Bool32,
16170 pub depth_compare_op: crate::vk1_0::CompareOp,
16171 pub depth_bounds_test_enable: crate::vk1_0::Bool32,
16172 pub stencil_test_enable: crate::vk1_0::Bool32,
16173 pub front: crate::vk1_0::StencilOpState,
16174 pub back: crate::vk1_0::StencilOpState,
16175 pub min_depth_bounds: std::os::raw::c_float,
16176 pub max_depth_bounds: std::os::raw::c_float,
16177}
16178impl PipelineDepthStencilStateCreateInfo {
16179 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
16180}
16181impl Default for PipelineDepthStencilStateCreateInfo {
16182 fn default() -> Self {
16183 Self {
16184 s_type: Self::STRUCTURE_TYPE,
16185 p_next: std::ptr::null(),
16186 flags: Default::default(),
16187 depth_test_enable: Default::default(),
16188 depth_write_enable: Default::default(),
16189 depth_compare_op: Default::default(),
16190 depth_bounds_test_enable: Default::default(),
16191 stencil_test_enable: Default::default(),
16192 front: Default::default(),
16193 back: Default::default(),
16194 min_depth_bounds: Default::default(),
16195 max_depth_bounds: Default::default(),
16196 }
16197 }
16198}
16199impl std::fmt::Debug for PipelineDepthStencilStateCreateInfo {
16200 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16201 f.debug_struct("PipelineDepthStencilStateCreateInfo")
16202 .field("s_type", &self.s_type)
16203 .field("p_next", &self.p_next)
16204 .field("flags", &self.flags)
16205 .field("depth_test_enable", &(self.depth_test_enable != 0))
16206 .field("depth_write_enable", &(self.depth_write_enable != 0))
16207 .field("depth_compare_op", &self.depth_compare_op)
16208 .field("depth_bounds_test_enable", &(self.depth_bounds_test_enable != 0))
16209 .field("stencil_test_enable", &(self.stencil_test_enable != 0))
16210 .field("front", &self.front)
16211 .field("back", &self.back)
16212 .field("min_depth_bounds", &self.min_depth_bounds)
16213 .field("max_depth_bounds", &self.max_depth_bounds)
16214 .finish()
16215 }
16216}
16217impl PipelineDepthStencilStateCreateInfo {
16218 #[inline]
16219 pub fn into_builder<'a>(self) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
16220 PipelineDepthStencilStateCreateInfoBuilder(self, std::marker::PhantomData)
16221 }
16222}
16223#[derive(Copy, Clone)]
16224#[repr(transparent)]
16226pub struct PipelineDepthStencilStateCreateInfoBuilder<'a>(
16227 PipelineDepthStencilStateCreateInfo,
16228 std::marker::PhantomData<&'a ()>,
16229);
16230impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
16231 #[inline]
16232 pub fn new() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
16233 PipelineDepthStencilStateCreateInfoBuilder(
16234 Default::default(),
16235 std::marker::PhantomData,
16236 )
16237 }
16238 #[inline]
16239 #[must_use]
16240 pub fn flags(
16241 mut self,
16242 flags: crate::vk1_0::PipelineDepthStencilStateCreateFlags,
16243 ) -> Self {
16244 self.0.flags = flags as _;
16245 self
16246 }
16247 #[inline]
16248 #[must_use]
16249 pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self {
16250 self.0.depth_test_enable = depth_test_enable as _;
16251 self
16252 }
16253 #[inline]
16254 #[must_use]
16255 pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self {
16256 self.0.depth_write_enable = depth_write_enable as _;
16257 self
16258 }
16259 #[inline]
16260 #[must_use]
16261 pub fn depth_compare_op(
16262 mut self,
16263 depth_compare_op: crate::vk1_0::CompareOp,
16264 ) -> Self {
16265 self.0.depth_compare_op = depth_compare_op as _;
16266 self
16267 }
16268 #[inline]
16269 #[must_use]
16270 pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self {
16271 self.0.depth_bounds_test_enable = depth_bounds_test_enable as _;
16272 self
16273 }
16274 #[inline]
16275 #[must_use]
16276 pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self {
16277 self.0.stencil_test_enable = stencil_test_enable as _;
16278 self
16279 }
16280 #[inline]
16281 #[must_use]
16282 pub fn front(mut self, front: crate::vk1_0::StencilOpState) -> Self {
16283 self.0.front = front as _;
16284 self
16285 }
16286 #[inline]
16287 #[must_use]
16288 pub fn back(mut self, back: crate::vk1_0::StencilOpState) -> Self {
16289 self.0.back = back as _;
16290 self
16291 }
16292 #[inline]
16293 #[must_use]
16294 pub fn min_depth_bounds(mut self, min_depth_bounds: std::os::raw::c_float) -> Self {
16295 self.0.min_depth_bounds = min_depth_bounds as _;
16296 self
16297 }
16298 #[inline]
16299 #[must_use]
16300 pub fn max_depth_bounds(mut self, max_depth_bounds: std::os::raw::c_float) -> Self {
16301 self.0.max_depth_bounds = max_depth_bounds as _;
16302 self
16303 }
16304 #[inline]
16305 pub fn build_dangling(self) -> PipelineDepthStencilStateCreateInfo {
16308 self.0
16309 }
16310}
16311impl<'a> std::default::Default for PipelineDepthStencilStateCreateInfoBuilder<'a> {
16312 fn default() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
16313 Self::new()
16314 }
16315}
16316impl<'a> std::fmt::Debug for PipelineDepthStencilStateCreateInfoBuilder<'a> {
16317 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16318 std::fmt::Debug::fmt(&self.0, f)
16319 }
16320}
16321impl<'a> std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> {
16322 type Target = PipelineDepthStencilStateCreateInfo;
16323 fn deref(&self) -> &Self::Target {
16324 &self.0
16325 }
16326}
16327impl<'a> std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> {
16328 fn deref_mut(&mut self) -> &mut Self::Target {
16329 &mut self.0
16330 }
16331}
16332#[doc(alias = "VkGraphicsPipelineCreateInfo")]
16334#[derive(Copy, Clone)]
16335#[repr(C)]
16336pub struct GraphicsPipelineCreateInfo {
16337 pub s_type: crate::vk1_0::StructureType,
16338 pub p_next: *const std::ffi::c_void,
16339 pub flags: crate::vk1_0::PipelineCreateFlags,
16340 pub stage_count: u32,
16341 pub p_stages: *const crate::vk1_0::PipelineShaderStageCreateInfo,
16342 pub p_vertex_input_state: *const crate::vk1_0::PipelineVertexInputStateCreateInfo,
16343 pub p_input_assembly_state: *const crate::vk1_0::PipelineInputAssemblyStateCreateInfo,
16344 pub p_tessellation_state: *const crate::vk1_0::PipelineTessellationStateCreateInfo,
16345 pub p_viewport_state: *const crate::vk1_0::PipelineViewportStateCreateInfo,
16346 pub p_rasterization_state: *const crate::vk1_0::PipelineRasterizationStateCreateInfo,
16347 pub p_multisample_state: *const crate::vk1_0::PipelineMultisampleStateCreateInfo,
16348 pub p_depth_stencil_state: *const crate::vk1_0::PipelineDepthStencilStateCreateInfo,
16349 pub p_color_blend_state: *const crate::vk1_0::PipelineColorBlendStateCreateInfo,
16350 pub p_dynamic_state: *const crate::vk1_0::PipelineDynamicStateCreateInfo,
16351 pub layout: crate::vk1_0::PipelineLayout,
16352 pub render_pass: crate::vk1_0::RenderPass,
16353 pub subpass: u32,
16354 pub base_pipeline_handle: crate::vk1_0::Pipeline,
16355 pub base_pipeline_index: i32,
16356}
16357impl GraphicsPipelineCreateInfo {
16358 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::GRAPHICS_PIPELINE_CREATE_INFO;
16359}
16360impl Default for GraphicsPipelineCreateInfo {
16361 fn default() -> Self {
16362 Self {
16363 s_type: Self::STRUCTURE_TYPE,
16364 p_next: std::ptr::null(),
16365 flags: Default::default(),
16366 stage_count: Default::default(),
16367 p_stages: std::ptr::null(),
16368 p_vertex_input_state: std::ptr::null(),
16369 p_input_assembly_state: std::ptr::null(),
16370 p_tessellation_state: std::ptr::null(),
16371 p_viewport_state: std::ptr::null(),
16372 p_rasterization_state: std::ptr::null(),
16373 p_multisample_state: std::ptr::null(),
16374 p_depth_stencil_state: std::ptr::null(),
16375 p_color_blend_state: std::ptr::null(),
16376 p_dynamic_state: std::ptr::null(),
16377 layout: Default::default(),
16378 render_pass: Default::default(),
16379 subpass: Default::default(),
16380 base_pipeline_handle: Default::default(),
16381 base_pipeline_index: Default::default(),
16382 }
16383 }
16384}
16385impl std::fmt::Debug for GraphicsPipelineCreateInfo {
16386 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16387 f.debug_struct("GraphicsPipelineCreateInfo")
16388 .field("s_type", &self.s_type)
16389 .field("p_next", &self.p_next)
16390 .field("flags", &self.flags)
16391 .field("stage_count", &self.stage_count)
16392 .field("p_stages", &self.p_stages)
16393 .field("p_vertex_input_state", &self.p_vertex_input_state)
16394 .field("p_input_assembly_state", &self.p_input_assembly_state)
16395 .field("p_tessellation_state", &self.p_tessellation_state)
16396 .field("p_viewport_state", &self.p_viewport_state)
16397 .field("p_rasterization_state", &self.p_rasterization_state)
16398 .field("p_multisample_state", &self.p_multisample_state)
16399 .field("p_depth_stencil_state", &self.p_depth_stencil_state)
16400 .field("p_color_blend_state", &self.p_color_blend_state)
16401 .field("p_dynamic_state", &self.p_dynamic_state)
16402 .field("layout", &self.layout)
16403 .field("render_pass", &self.render_pass)
16404 .field("subpass", &self.subpass)
16405 .field("base_pipeline_handle", &self.base_pipeline_handle)
16406 .field("base_pipeline_index", &self.base_pipeline_index)
16407 .finish()
16408 }
16409}
16410impl GraphicsPipelineCreateInfo {
16411 #[inline]
16412 pub fn into_builder<'a>(self) -> GraphicsPipelineCreateInfoBuilder<'a> {
16413 GraphicsPipelineCreateInfoBuilder(self, std::marker::PhantomData)
16414 }
16415}
16416#[derive(Copy, Clone)]
16417#[repr(transparent)]
16419pub struct GraphicsPipelineCreateInfoBuilder<'a>(
16420 GraphicsPipelineCreateInfo,
16421 std::marker::PhantomData<&'a ()>,
16422);
16423impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
16424 #[inline]
16425 pub fn new() -> GraphicsPipelineCreateInfoBuilder<'a> {
16426 GraphicsPipelineCreateInfoBuilder(Default::default(), std::marker::PhantomData)
16427 }
16428 #[inline]
16429 #[must_use]
16430 pub fn flags(mut self, flags: crate::vk1_0::PipelineCreateFlags) -> Self {
16431 self.0.flags = flags as _;
16432 self
16433 }
16434 #[inline]
16435 #[must_use]
16436 pub fn stages(
16437 mut self,
16438 stages: &'a [crate::vk1_0::PipelineShaderStageCreateInfoBuilder],
16439 ) -> Self {
16440 self.0.p_stages = stages.as_ptr() as _;
16441 self.0.stage_count = stages.len() as _;
16442 self
16443 }
16444 #[inline]
16445 #[must_use]
16446 pub fn vertex_input_state(
16447 mut self,
16448 vertex_input_state: &'a crate::vk1_0::PipelineVertexInputStateCreateInfo,
16449 ) -> Self {
16450 self.0.p_vertex_input_state = vertex_input_state as _;
16451 self
16452 }
16453 #[inline]
16454 #[must_use]
16455 pub fn input_assembly_state(
16456 mut self,
16457 input_assembly_state: &'a crate::vk1_0::PipelineInputAssemblyStateCreateInfo,
16458 ) -> Self {
16459 self.0.p_input_assembly_state = input_assembly_state as _;
16460 self
16461 }
16462 #[inline]
16463 #[must_use]
16464 pub fn tessellation_state(
16465 mut self,
16466 tessellation_state: &'a crate::vk1_0::PipelineTessellationStateCreateInfo,
16467 ) -> Self {
16468 self.0.p_tessellation_state = tessellation_state as _;
16469 self
16470 }
16471 #[inline]
16472 #[must_use]
16473 pub fn viewport_state(
16474 mut self,
16475 viewport_state: &'a crate::vk1_0::PipelineViewportStateCreateInfo,
16476 ) -> Self {
16477 self.0.p_viewport_state = viewport_state as _;
16478 self
16479 }
16480 #[inline]
16481 #[must_use]
16482 pub fn rasterization_state(
16483 mut self,
16484 rasterization_state: &'a crate::vk1_0::PipelineRasterizationStateCreateInfo,
16485 ) -> Self {
16486 self.0.p_rasterization_state = rasterization_state as _;
16487 self
16488 }
16489 #[inline]
16490 #[must_use]
16491 pub fn multisample_state(
16492 mut self,
16493 multisample_state: &'a crate::vk1_0::PipelineMultisampleStateCreateInfo,
16494 ) -> Self {
16495 self.0.p_multisample_state = multisample_state as _;
16496 self
16497 }
16498 #[inline]
16499 #[must_use]
16500 pub fn depth_stencil_state(
16501 mut self,
16502 depth_stencil_state: &'a crate::vk1_0::PipelineDepthStencilStateCreateInfo,
16503 ) -> Self {
16504 self.0.p_depth_stencil_state = depth_stencil_state as _;
16505 self
16506 }
16507 #[inline]
16508 #[must_use]
16509 pub fn color_blend_state(
16510 mut self,
16511 color_blend_state: &'a crate::vk1_0::PipelineColorBlendStateCreateInfo,
16512 ) -> Self {
16513 self.0.p_color_blend_state = color_blend_state as _;
16514 self
16515 }
16516 #[inline]
16517 #[must_use]
16518 pub fn dynamic_state(
16519 mut self,
16520 dynamic_state: &'a crate::vk1_0::PipelineDynamicStateCreateInfo,
16521 ) -> Self {
16522 self.0.p_dynamic_state = dynamic_state as _;
16523 self
16524 }
16525 #[inline]
16526 #[must_use]
16527 pub fn layout(mut self, layout: crate::vk1_0::PipelineLayout) -> Self {
16528 self.0.layout = layout as _;
16529 self
16530 }
16531 #[inline]
16532 #[must_use]
16533 pub fn render_pass(mut self, render_pass: crate::vk1_0::RenderPass) -> Self {
16534 self.0.render_pass = render_pass as _;
16535 self
16536 }
16537 #[inline]
16538 #[must_use]
16539 pub fn subpass(mut self, subpass: u32) -> Self {
16540 self.0.subpass = subpass as _;
16541 self
16542 }
16543 #[inline]
16544 #[must_use]
16545 pub fn base_pipeline_handle(
16546 mut self,
16547 base_pipeline_handle: crate::vk1_0::Pipeline,
16548 ) -> Self {
16549 self.0.base_pipeline_handle = base_pipeline_handle as _;
16550 self
16551 }
16552 #[inline]
16553 #[must_use]
16554 pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
16555 self.0.base_pipeline_index = base_pipeline_index as _;
16556 self
16557 }
16558 #[inline]
16559 pub fn build_dangling(self) -> GraphicsPipelineCreateInfo {
16562 self.0
16563 }
16564}
16565impl<'a> std::default::Default for GraphicsPipelineCreateInfoBuilder<'a> {
16566 fn default() -> GraphicsPipelineCreateInfoBuilder<'a> {
16567 Self::new()
16568 }
16569}
16570impl<'a> std::fmt::Debug for GraphicsPipelineCreateInfoBuilder<'a> {
16571 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16572 std::fmt::Debug::fmt(&self.0, f)
16573 }
16574}
16575impl<'a> std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> {
16576 type Target = GraphicsPipelineCreateInfo;
16577 fn deref(&self) -> &Self::Target {
16578 &self.0
16579 }
16580}
16581impl<'a> std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> {
16582 fn deref_mut(&mut self) -> &mut Self::Target {
16583 &mut self.0
16584 }
16585}
16586#[doc(alias = "VkPipelineCacheCreateInfo")]
16588#[derive(Copy, Clone)]
16589#[repr(C)]
16590pub struct PipelineCacheCreateInfo {
16591 pub s_type: crate::vk1_0::StructureType,
16592 pub p_next: *const std::ffi::c_void,
16593 pub flags: crate::vk1_0::PipelineCacheCreateFlags,
16594 pub initial_data_size: usize,
16595 pub p_initial_data: *const std::ffi::c_void,
16596}
16597impl PipelineCacheCreateInfo {
16598 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_CACHE_CREATE_INFO;
16599}
16600impl Default for PipelineCacheCreateInfo {
16601 fn default() -> Self {
16602 Self {
16603 s_type: Self::STRUCTURE_TYPE,
16604 p_next: std::ptr::null(),
16605 flags: Default::default(),
16606 initial_data_size: Default::default(),
16607 p_initial_data: std::ptr::null(),
16608 }
16609 }
16610}
16611impl std::fmt::Debug for PipelineCacheCreateInfo {
16612 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16613 f.debug_struct("PipelineCacheCreateInfo")
16614 .field("s_type", &self.s_type)
16615 .field("p_next", &self.p_next)
16616 .field("flags", &self.flags)
16617 .field("initial_data_size", &self.initial_data_size)
16618 .field("p_initial_data", &self.p_initial_data)
16619 .finish()
16620 }
16621}
16622impl PipelineCacheCreateInfo {
16623 #[inline]
16624 pub fn into_builder<'a>(self) -> PipelineCacheCreateInfoBuilder<'a> {
16625 PipelineCacheCreateInfoBuilder(self, std::marker::PhantomData)
16626 }
16627}
16628#[derive(Copy, Clone)]
16629#[repr(transparent)]
16631pub struct PipelineCacheCreateInfoBuilder<'a>(
16632 PipelineCacheCreateInfo,
16633 std::marker::PhantomData<&'a ()>,
16634);
16635impl<'a> PipelineCacheCreateInfoBuilder<'a> {
16636 #[inline]
16637 pub fn new() -> PipelineCacheCreateInfoBuilder<'a> {
16638 PipelineCacheCreateInfoBuilder(Default::default(), std::marker::PhantomData)
16639 }
16640 #[inline]
16641 #[must_use]
16642 pub fn flags(mut self, flags: crate::vk1_0::PipelineCacheCreateFlags) -> Self {
16643 self.0.flags = flags as _;
16644 self
16645 }
16646 #[inline]
16647 #[must_use]
16648 pub fn initial_data_size(mut self, initial_data_size: usize) -> Self {
16649 self.0.initial_data_size = initial_data_size;
16650 self
16651 }
16652 #[inline]
16653 #[must_use]
16654 pub fn initial_data(mut self, initial_data: *const std::ffi::c_void) -> Self {
16655 self.0.p_initial_data = initial_data;
16656 self
16657 }
16658 #[inline]
16659 pub fn build_dangling(self) -> PipelineCacheCreateInfo {
16662 self.0
16663 }
16664}
16665impl<'a> std::default::Default for PipelineCacheCreateInfoBuilder<'a> {
16666 fn default() -> PipelineCacheCreateInfoBuilder<'a> {
16667 Self::new()
16668 }
16669}
16670impl<'a> std::fmt::Debug for PipelineCacheCreateInfoBuilder<'a> {
16671 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16672 std::fmt::Debug::fmt(&self.0, f)
16673 }
16674}
16675impl<'a> std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> {
16676 type Target = PipelineCacheCreateInfo;
16677 fn deref(&self) -> &Self::Target {
16678 &self.0
16679 }
16680}
16681impl<'a> std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> {
16682 fn deref_mut(&mut self) -> &mut Self::Target {
16683 &mut self.0
16684 }
16685}
16686#[doc(alias = "VkPipelineCacheHeaderVersionOne")]
16688#[derive(Copy, Clone, Hash, PartialEq, Eq)]
16689#[repr(C)]
16690pub struct PipelineCacheHeaderVersionOne {
16691 pub header_size: u32,
16692 pub header_version: crate::vk1_0::PipelineCacheHeaderVersion,
16693 pub vendor_id: u32,
16694 pub device_id: u32,
16695 pub pipeline_cache_uuid: [u8; 16],
16696}
16697impl Default for PipelineCacheHeaderVersionOne {
16698 fn default() -> Self {
16699 Self {
16700 header_size: Default::default(),
16701 header_version: Default::default(),
16702 vendor_id: Default::default(),
16703 device_id: Default::default(),
16704 pipeline_cache_uuid: unsafe { std::mem::zeroed() },
16705 }
16706 }
16707}
16708impl std::fmt::Debug for PipelineCacheHeaderVersionOne {
16709 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16710 f.debug_struct("PipelineCacheHeaderVersionOne")
16711 .field("header_size", &self.header_size)
16712 .field("header_version", &self.header_version)
16713 .field("vendor_id", &self.vendor_id)
16714 .field("device_id", &self.device_id)
16715 .field("pipeline_cache_uuid", &self.pipeline_cache_uuid)
16716 .finish()
16717 }
16718}
16719impl PipelineCacheHeaderVersionOne {
16720 #[inline]
16721 pub fn into_builder<'a>(self) -> PipelineCacheHeaderVersionOneBuilder<'a> {
16722 PipelineCacheHeaderVersionOneBuilder(self, std::marker::PhantomData)
16723 }
16724}
16725#[derive(Copy, Clone)]
16726#[repr(transparent)]
16728pub struct PipelineCacheHeaderVersionOneBuilder<'a>(
16729 PipelineCacheHeaderVersionOne,
16730 std::marker::PhantomData<&'a ()>,
16731);
16732impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> {
16733 #[inline]
16734 pub fn new() -> PipelineCacheHeaderVersionOneBuilder<'a> {
16735 PipelineCacheHeaderVersionOneBuilder(
16736 Default::default(),
16737 std::marker::PhantomData,
16738 )
16739 }
16740 #[inline]
16741 #[must_use]
16742 pub fn header_size(mut self, header_size: u32) -> Self {
16743 self.0.header_size = header_size as _;
16744 self
16745 }
16746 #[inline]
16747 #[must_use]
16748 pub fn header_version(
16749 mut self,
16750 header_version: crate::vk1_0::PipelineCacheHeaderVersion,
16751 ) -> Self {
16752 self.0.header_version = header_version as _;
16753 self
16754 }
16755 #[inline]
16756 #[must_use]
16757 pub fn vendor_id(mut self, vendor_id: u32) -> Self {
16758 self.0.vendor_id = vendor_id as _;
16759 self
16760 }
16761 #[inline]
16762 #[must_use]
16763 pub fn device_id(mut self, device_id: u32) -> Self {
16764 self.0.device_id = device_id as _;
16765 self
16766 }
16767 #[inline]
16768 #[must_use]
16769 pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; 16]) -> Self {
16770 self.0.pipeline_cache_uuid = pipeline_cache_uuid as _;
16771 self
16772 }
16773 #[inline]
16774 pub fn build(self) -> PipelineCacheHeaderVersionOne {
16775 self.0
16776 }
16777}
16778impl<'a> std::default::Default for PipelineCacheHeaderVersionOneBuilder<'a> {
16779 fn default() -> PipelineCacheHeaderVersionOneBuilder<'a> {
16780 Self::new()
16781 }
16782}
16783impl<'a> std::fmt::Debug for PipelineCacheHeaderVersionOneBuilder<'a> {
16784 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16785 std::fmt::Debug::fmt(&self.0, f)
16786 }
16787}
16788impl<'a> std::ops::Deref for PipelineCacheHeaderVersionOneBuilder<'a> {
16789 type Target = PipelineCacheHeaderVersionOne;
16790 fn deref(&self) -> &Self::Target {
16791 &self.0
16792 }
16793}
16794impl<'a> std::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder<'a> {
16795 fn deref_mut(&mut self) -> &mut Self::Target {
16796 &mut self.0
16797 }
16798}
16799#[doc(alias = "VkPushConstantRange")]
16801#[derive(Copy, Clone, Hash, PartialEq, Eq)]
16802#[repr(C)]
16803pub struct PushConstantRange {
16804 pub stage_flags: crate::vk1_0::ShaderStageFlags,
16805 pub offset: u32,
16806 pub size: u32,
16807}
16808impl Default for PushConstantRange {
16809 fn default() -> Self {
16810 Self {
16811 stage_flags: Default::default(),
16812 offset: Default::default(),
16813 size: Default::default(),
16814 }
16815 }
16816}
16817impl std::fmt::Debug for PushConstantRange {
16818 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16819 f.debug_struct("PushConstantRange")
16820 .field("stage_flags", &self.stage_flags)
16821 .field("offset", &self.offset)
16822 .field("size", &self.size)
16823 .finish()
16824 }
16825}
16826impl PushConstantRange {
16827 #[inline]
16828 pub fn into_builder<'a>(self) -> PushConstantRangeBuilder<'a> {
16829 PushConstantRangeBuilder(self, std::marker::PhantomData)
16830 }
16831}
16832#[derive(Copy, Clone)]
16833#[repr(transparent)]
16835pub struct PushConstantRangeBuilder<'a>(
16836 PushConstantRange,
16837 std::marker::PhantomData<&'a ()>,
16838);
16839impl<'a> PushConstantRangeBuilder<'a> {
16840 #[inline]
16841 pub fn new() -> PushConstantRangeBuilder<'a> {
16842 PushConstantRangeBuilder(Default::default(), std::marker::PhantomData)
16843 }
16844 #[inline]
16845 #[must_use]
16846 pub fn stage_flags(mut self, stage_flags: crate::vk1_0::ShaderStageFlags) -> Self {
16847 self.0.stage_flags = stage_flags as _;
16848 self
16849 }
16850 #[inline]
16851 #[must_use]
16852 pub fn offset(mut self, offset: u32) -> Self {
16853 self.0.offset = offset as _;
16854 self
16855 }
16856 #[inline]
16857 #[must_use]
16858 pub fn size(mut self, size: u32) -> Self {
16859 self.0.size = size as _;
16860 self
16861 }
16862 #[inline]
16863 pub fn build(self) -> PushConstantRange {
16864 self.0
16865 }
16866}
16867impl<'a> std::default::Default for PushConstantRangeBuilder<'a> {
16868 fn default() -> PushConstantRangeBuilder<'a> {
16869 Self::new()
16870 }
16871}
16872impl<'a> std::fmt::Debug for PushConstantRangeBuilder<'a> {
16873 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16874 std::fmt::Debug::fmt(&self.0, f)
16875 }
16876}
16877impl<'a> std::ops::Deref for PushConstantRangeBuilder<'a> {
16878 type Target = PushConstantRange;
16879 fn deref(&self) -> &Self::Target {
16880 &self.0
16881 }
16882}
16883impl<'a> std::ops::DerefMut for PushConstantRangeBuilder<'a> {
16884 fn deref_mut(&mut self) -> &mut Self::Target {
16885 &mut self.0
16886 }
16887}
16888#[doc(alias = "VkPipelineLayoutCreateInfo")]
16890#[derive(Copy, Clone)]
16891#[repr(C)]
16892pub struct PipelineLayoutCreateInfo {
16893 pub s_type: crate::vk1_0::StructureType,
16894 pub p_next: *const std::ffi::c_void,
16895 pub flags: crate::vk1_0::PipelineLayoutCreateFlags,
16896 pub set_layout_count: u32,
16897 pub p_set_layouts: *const crate::vk1_0::DescriptorSetLayout,
16898 pub push_constant_range_count: u32,
16899 pub p_push_constant_ranges: *const crate::vk1_0::PushConstantRange,
16900}
16901impl PipelineLayoutCreateInfo {
16902 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PIPELINE_LAYOUT_CREATE_INFO;
16903}
16904impl Default for PipelineLayoutCreateInfo {
16905 fn default() -> Self {
16906 Self {
16907 s_type: Self::STRUCTURE_TYPE,
16908 p_next: std::ptr::null(),
16909 flags: Default::default(),
16910 set_layout_count: Default::default(),
16911 p_set_layouts: std::ptr::null(),
16912 push_constant_range_count: Default::default(),
16913 p_push_constant_ranges: std::ptr::null(),
16914 }
16915 }
16916}
16917impl std::fmt::Debug for PipelineLayoutCreateInfo {
16918 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16919 f.debug_struct("PipelineLayoutCreateInfo")
16920 .field("s_type", &self.s_type)
16921 .field("p_next", &self.p_next)
16922 .field("flags", &self.flags)
16923 .field("set_layout_count", &self.set_layout_count)
16924 .field("p_set_layouts", &self.p_set_layouts)
16925 .field("push_constant_range_count", &self.push_constant_range_count)
16926 .field("p_push_constant_ranges", &self.p_push_constant_ranges)
16927 .finish()
16928 }
16929}
16930impl PipelineLayoutCreateInfo {
16931 #[inline]
16932 pub fn into_builder<'a>(self) -> PipelineLayoutCreateInfoBuilder<'a> {
16933 PipelineLayoutCreateInfoBuilder(self, std::marker::PhantomData)
16934 }
16935}
16936#[derive(Copy, Clone)]
16937#[repr(transparent)]
16939pub struct PipelineLayoutCreateInfoBuilder<'a>(
16940 PipelineLayoutCreateInfo,
16941 std::marker::PhantomData<&'a ()>,
16942);
16943impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
16944 #[inline]
16945 pub fn new() -> PipelineLayoutCreateInfoBuilder<'a> {
16946 PipelineLayoutCreateInfoBuilder(Default::default(), std::marker::PhantomData)
16947 }
16948 #[inline]
16949 #[must_use]
16950 pub fn flags(mut self, flags: crate::vk1_0::PipelineLayoutCreateFlags) -> Self {
16951 self.0.flags = flags as _;
16952 self
16953 }
16954 #[inline]
16955 #[must_use]
16956 pub fn set_layouts(
16957 mut self,
16958 set_layouts: &'a [crate::vk1_0::DescriptorSetLayout],
16959 ) -> Self {
16960 self.0.p_set_layouts = set_layouts.as_ptr() as _;
16961 self.0.set_layout_count = set_layouts.len() as _;
16962 self
16963 }
16964 #[inline]
16965 #[must_use]
16966 pub fn push_constant_ranges(
16967 mut self,
16968 push_constant_ranges: &'a [crate::vk1_0::PushConstantRangeBuilder],
16969 ) -> Self {
16970 self.0.p_push_constant_ranges = push_constant_ranges.as_ptr() as _;
16971 self.0.push_constant_range_count = push_constant_ranges.len() as _;
16972 self
16973 }
16974 #[inline]
16975 pub fn build_dangling(self) -> PipelineLayoutCreateInfo {
16978 self.0
16979 }
16980}
16981impl<'a> std::default::Default for PipelineLayoutCreateInfoBuilder<'a> {
16982 fn default() -> PipelineLayoutCreateInfoBuilder<'a> {
16983 Self::new()
16984 }
16985}
16986impl<'a> std::fmt::Debug for PipelineLayoutCreateInfoBuilder<'a> {
16987 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
16988 std::fmt::Debug::fmt(&self.0, f)
16989 }
16990}
16991impl<'a> std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> {
16992 type Target = PipelineLayoutCreateInfo;
16993 fn deref(&self) -> &Self::Target {
16994 &self.0
16995 }
16996}
16997impl<'a> std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> {
16998 fn deref_mut(&mut self) -> &mut Self::Target {
16999 &mut self.0
17000 }
17001}
17002#[doc(alias = "VkSamplerCreateInfo")]
17004#[derive(Copy, Clone)]
17005#[repr(C)]
17006pub struct SamplerCreateInfo {
17007 pub s_type: crate::vk1_0::StructureType,
17008 pub p_next: *const std::ffi::c_void,
17009 pub flags: crate::vk1_0::SamplerCreateFlags,
17010 pub mag_filter: crate::vk1_0::Filter,
17011 pub min_filter: crate::vk1_0::Filter,
17012 pub mipmap_mode: crate::vk1_0::SamplerMipmapMode,
17013 pub address_mode_u: crate::vk1_0::SamplerAddressMode,
17014 pub address_mode_v: crate::vk1_0::SamplerAddressMode,
17015 pub address_mode_w: crate::vk1_0::SamplerAddressMode,
17016 pub mip_lod_bias: std::os::raw::c_float,
17017 pub anisotropy_enable: crate::vk1_0::Bool32,
17018 pub max_anisotropy: std::os::raw::c_float,
17019 pub compare_enable: crate::vk1_0::Bool32,
17020 pub compare_op: crate::vk1_0::CompareOp,
17021 pub min_lod: std::os::raw::c_float,
17022 pub max_lod: std::os::raw::c_float,
17023 pub border_color: crate::vk1_0::BorderColor,
17024 pub unnormalized_coordinates: crate::vk1_0::Bool32,
17025}
17026impl SamplerCreateInfo {
17027 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::SAMPLER_CREATE_INFO;
17028}
17029impl Default for SamplerCreateInfo {
17030 fn default() -> Self {
17031 Self {
17032 s_type: Self::STRUCTURE_TYPE,
17033 p_next: std::ptr::null(),
17034 flags: Default::default(),
17035 mag_filter: Default::default(),
17036 min_filter: Default::default(),
17037 mipmap_mode: Default::default(),
17038 address_mode_u: Default::default(),
17039 address_mode_v: Default::default(),
17040 address_mode_w: Default::default(),
17041 mip_lod_bias: Default::default(),
17042 anisotropy_enable: Default::default(),
17043 max_anisotropy: Default::default(),
17044 compare_enable: Default::default(),
17045 compare_op: Default::default(),
17046 min_lod: Default::default(),
17047 max_lod: Default::default(),
17048 border_color: Default::default(),
17049 unnormalized_coordinates: Default::default(),
17050 }
17051 }
17052}
17053impl std::fmt::Debug for SamplerCreateInfo {
17054 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17055 f.debug_struct("SamplerCreateInfo")
17056 .field("s_type", &self.s_type)
17057 .field("p_next", &self.p_next)
17058 .field("flags", &self.flags)
17059 .field("mag_filter", &self.mag_filter)
17060 .field("min_filter", &self.min_filter)
17061 .field("mipmap_mode", &self.mipmap_mode)
17062 .field("address_mode_u", &self.address_mode_u)
17063 .field("address_mode_v", &self.address_mode_v)
17064 .field("address_mode_w", &self.address_mode_w)
17065 .field("mip_lod_bias", &self.mip_lod_bias)
17066 .field("anisotropy_enable", &(self.anisotropy_enable != 0))
17067 .field("max_anisotropy", &self.max_anisotropy)
17068 .field("compare_enable", &(self.compare_enable != 0))
17069 .field("compare_op", &self.compare_op)
17070 .field("min_lod", &self.min_lod)
17071 .field("max_lod", &self.max_lod)
17072 .field("border_color", &self.border_color)
17073 .field("unnormalized_coordinates", &(self.unnormalized_coordinates != 0))
17074 .finish()
17075 }
17076}
17077impl SamplerCreateInfo {
17078 #[inline]
17079 pub fn into_builder<'a>(self) -> SamplerCreateInfoBuilder<'a> {
17080 SamplerCreateInfoBuilder(self, std::marker::PhantomData)
17081 }
17082}
17083#[derive(Copy, Clone)]
17084#[repr(transparent)]
17086pub struct SamplerCreateInfoBuilder<'a>(
17087 SamplerCreateInfo,
17088 std::marker::PhantomData<&'a ()>,
17089);
17090impl<'a> SamplerCreateInfoBuilder<'a> {
17091 #[inline]
17092 pub fn new() -> SamplerCreateInfoBuilder<'a> {
17093 SamplerCreateInfoBuilder(Default::default(), std::marker::PhantomData)
17094 }
17095 #[inline]
17096 #[must_use]
17097 pub fn flags(mut self, flags: crate::vk1_0::SamplerCreateFlags) -> Self {
17098 self.0.flags = flags as _;
17099 self
17100 }
17101 #[inline]
17102 #[must_use]
17103 pub fn mag_filter(mut self, mag_filter: crate::vk1_0::Filter) -> Self {
17104 self.0.mag_filter = mag_filter as _;
17105 self
17106 }
17107 #[inline]
17108 #[must_use]
17109 pub fn min_filter(mut self, min_filter: crate::vk1_0::Filter) -> Self {
17110 self.0.min_filter = min_filter as _;
17111 self
17112 }
17113 #[inline]
17114 #[must_use]
17115 pub fn mipmap_mode(mut self, mipmap_mode: crate::vk1_0::SamplerMipmapMode) -> Self {
17116 self.0.mipmap_mode = mipmap_mode as _;
17117 self
17118 }
17119 #[inline]
17120 #[must_use]
17121 pub fn address_mode_u(
17122 mut self,
17123 address_mode_u: crate::vk1_0::SamplerAddressMode,
17124 ) -> Self {
17125 self.0.address_mode_u = address_mode_u as _;
17126 self
17127 }
17128 #[inline]
17129 #[must_use]
17130 pub fn address_mode_v(
17131 mut self,
17132 address_mode_v: crate::vk1_0::SamplerAddressMode,
17133 ) -> Self {
17134 self.0.address_mode_v = address_mode_v as _;
17135 self
17136 }
17137 #[inline]
17138 #[must_use]
17139 pub fn address_mode_w(
17140 mut self,
17141 address_mode_w: crate::vk1_0::SamplerAddressMode,
17142 ) -> Self {
17143 self.0.address_mode_w = address_mode_w as _;
17144 self
17145 }
17146 #[inline]
17147 #[must_use]
17148 pub fn mip_lod_bias(mut self, mip_lod_bias: std::os::raw::c_float) -> Self {
17149 self.0.mip_lod_bias = mip_lod_bias as _;
17150 self
17151 }
17152 #[inline]
17153 #[must_use]
17154 pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self {
17155 self.0.anisotropy_enable = anisotropy_enable as _;
17156 self
17157 }
17158 #[inline]
17159 #[must_use]
17160 pub fn max_anisotropy(mut self, max_anisotropy: std::os::raw::c_float) -> Self {
17161 self.0.max_anisotropy = max_anisotropy as _;
17162 self
17163 }
17164 #[inline]
17165 #[must_use]
17166 pub fn compare_enable(mut self, compare_enable: bool) -> Self {
17167 self.0.compare_enable = compare_enable as _;
17168 self
17169 }
17170 #[inline]
17171 #[must_use]
17172 pub fn compare_op(mut self, compare_op: crate::vk1_0::CompareOp) -> Self {
17173 self.0.compare_op = compare_op as _;
17174 self
17175 }
17176 #[inline]
17177 #[must_use]
17178 pub fn min_lod(mut self, min_lod: std::os::raw::c_float) -> Self {
17179 self.0.min_lod = min_lod as _;
17180 self
17181 }
17182 #[inline]
17183 #[must_use]
17184 pub fn max_lod(mut self, max_lod: std::os::raw::c_float) -> Self {
17185 self.0.max_lod = max_lod as _;
17186 self
17187 }
17188 #[inline]
17189 #[must_use]
17190 pub fn border_color(mut self, border_color: crate::vk1_0::BorderColor) -> Self {
17191 self.0.border_color = border_color as _;
17192 self
17193 }
17194 #[inline]
17195 #[must_use]
17196 pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self {
17197 self.0.unnormalized_coordinates = unnormalized_coordinates as _;
17198 self
17199 }
17200 #[inline]
17201 pub fn build_dangling(self) -> SamplerCreateInfo {
17204 self.0
17205 }
17206}
17207impl<'a> std::default::Default for SamplerCreateInfoBuilder<'a> {
17208 fn default() -> SamplerCreateInfoBuilder<'a> {
17209 Self::new()
17210 }
17211}
17212impl<'a> std::fmt::Debug for SamplerCreateInfoBuilder<'a> {
17213 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17214 std::fmt::Debug::fmt(&self.0, f)
17215 }
17216}
17217impl<'a> std::ops::Deref for SamplerCreateInfoBuilder<'a> {
17218 type Target = SamplerCreateInfo;
17219 fn deref(&self) -> &Self::Target {
17220 &self.0
17221 }
17222}
17223impl<'a> std::ops::DerefMut for SamplerCreateInfoBuilder<'a> {
17224 fn deref_mut(&mut self) -> &mut Self::Target {
17225 &mut self.0
17226 }
17227}
17228#[doc(alias = "VkCommandPoolCreateInfo")]
17230#[derive(Copy, Clone)]
17231#[repr(C)]
17232pub struct CommandPoolCreateInfo {
17233 pub s_type: crate::vk1_0::StructureType,
17234 pub p_next: *const std::ffi::c_void,
17235 pub flags: crate::vk1_0::CommandPoolCreateFlags,
17236 pub queue_family_index: u32,
17237}
17238impl CommandPoolCreateInfo {
17239 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::COMMAND_POOL_CREATE_INFO;
17240}
17241impl Default for CommandPoolCreateInfo {
17242 fn default() -> Self {
17243 Self {
17244 s_type: Self::STRUCTURE_TYPE,
17245 p_next: std::ptr::null(),
17246 flags: Default::default(),
17247 queue_family_index: Default::default(),
17248 }
17249 }
17250}
17251impl std::fmt::Debug for CommandPoolCreateInfo {
17252 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17253 f.debug_struct("CommandPoolCreateInfo")
17254 .field("s_type", &self.s_type)
17255 .field("p_next", &self.p_next)
17256 .field("flags", &self.flags)
17257 .field("queue_family_index", &self.queue_family_index)
17258 .finish()
17259 }
17260}
17261impl CommandPoolCreateInfo {
17262 #[inline]
17263 pub fn into_builder<'a>(self) -> CommandPoolCreateInfoBuilder<'a> {
17264 CommandPoolCreateInfoBuilder(self, std::marker::PhantomData)
17265 }
17266}
17267#[derive(Copy, Clone)]
17268#[repr(transparent)]
17270pub struct CommandPoolCreateInfoBuilder<'a>(
17271 CommandPoolCreateInfo,
17272 std::marker::PhantomData<&'a ()>,
17273);
17274impl<'a> CommandPoolCreateInfoBuilder<'a> {
17275 #[inline]
17276 pub fn new() -> CommandPoolCreateInfoBuilder<'a> {
17277 CommandPoolCreateInfoBuilder(Default::default(), std::marker::PhantomData)
17278 }
17279 #[inline]
17280 #[must_use]
17281 pub fn flags(mut self, flags: crate::vk1_0::CommandPoolCreateFlags) -> Self {
17282 self.0.flags = flags as _;
17283 self
17284 }
17285 #[inline]
17286 #[must_use]
17287 pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
17288 self.0.queue_family_index = queue_family_index as _;
17289 self
17290 }
17291 #[inline]
17292 pub fn build_dangling(self) -> CommandPoolCreateInfo {
17295 self.0
17296 }
17297}
17298impl<'a> std::default::Default for CommandPoolCreateInfoBuilder<'a> {
17299 fn default() -> CommandPoolCreateInfoBuilder<'a> {
17300 Self::new()
17301 }
17302}
17303impl<'a> std::fmt::Debug for CommandPoolCreateInfoBuilder<'a> {
17304 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17305 std::fmt::Debug::fmt(&self.0, f)
17306 }
17307}
17308impl<'a> std::ops::Deref for CommandPoolCreateInfoBuilder<'a> {
17309 type Target = CommandPoolCreateInfo;
17310 fn deref(&self) -> &Self::Target {
17311 &self.0
17312 }
17313}
17314impl<'a> std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> {
17315 fn deref_mut(&mut self) -> &mut Self::Target {
17316 &mut self.0
17317 }
17318}
17319#[doc(alias = "VkCommandBufferAllocateInfo")]
17321#[derive(Copy, Clone)]
17322#[repr(C)]
17323pub struct CommandBufferAllocateInfo {
17324 pub s_type: crate::vk1_0::StructureType,
17325 pub p_next: *const std::ffi::c_void,
17326 pub command_pool: crate::vk1_0::CommandPool,
17327 pub level: crate::vk1_0::CommandBufferLevel,
17328 pub command_buffer_count: u32,
17329}
17330impl CommandBufferAllocateInfo {
17331 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::COMMAND_BUFFER_ALLOCATE_INFO;
17332}
17333impl Default for CommandBufferAllocateInfo {
17334 fn default() -> Self {
17335 Self {
17336 s_type: Self::STRUCTURE_TYPE,
17337 p_next: std::ptr::null(),
17338 command_pool: Default::default(),
17339 level: Default::default(),
17340 command_buffer_count: Default::default(),
17341 }
17342 }
17343}
17344impl std::fmt::Debug for CommandBufferAllocateInfo {
17345 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17346 f.debug_struct("CommandBufferAllocateInfo")
17347 .field("s_type", &self.s_type)
17348 .field("p_next", &self.p_next)
17349 .field("command_pool", &self.command_pool)
17350 .field("level", &self.level)
17351 .field("command_buffer_count", &self.command_buffer_count)
17352 .finish()
17353 }
17354}
17355impl CommandBufferAllocateInfo {
17356 #[inline]
17357 pub fn into_builder<'a>(self) -> CommandBufferAllocateInfoBuilder<'a> {
17358 CommandBufferAllocateInfoBuilder(self, std::marker::PhantomData)
17359 }
17360}
17361#[derive(Copy, Clone)]
17362#[repr(transparent)]
17364pub struct CommandBufferAllocateInfoBuilder<'a>(
17365 CommandBufferAllocateInfo,
17366 std::marker::PhantomData<&'a ()>,
17367);
17368impl<'a> CommandBufferAllocateInfoBuilder<'a> {
17369 #[inline]
17370 pub fn new() -> CommandBufferAllocateInfoBuilder<'a> {
17371 CommandBufferAllocateInfoBuilder(Default::default(), std::marker::PhantomData)
17372 }
17373 #[inline]
17374 #[must_use]
17375 pub fn command_pool(mut self, command_pool: crate::vk1_0::CommandPool) -> Self {
17376 self.0.command_pool = command_pool as _;
17377 self
17378 }
17379 #[inline]
17380 #[must_use]
17381 pub fn level(mut self, level: crate::vk1_0::CommandBufferLevel) -> Self {
17382 self.0.level = level as _;
17383 self
17384 }
17385 #[inline]
17386 #[must_use]
17387 pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self {
17388 self.0.command_buffer_count = command_buffer_count as _;
17389 self
17390 }
17391 #[inline]
17392 pub fn build_dangling(self) -> CommandBufferAllocateInfo {
17395 self.0
17396 }
17397}
17398impl<'a> std::default::Default for CommandBufferAllocateInfoBuilder<'a> {
17399 fn default() -> CommandBufferAllocateInfoBuilder<'a> {
17400 Self::new()
17401 }
17402}
17403impl<'a> std::fmt::Debug for CommandBufferAllocateInfoBuilder<'a> {
17404 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17405 std::fmt::Debug::fmt(&self.0, f)
17406 }
17407}
17408impl<'a> std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> {
17409 type Target = CommandBufferAllocateInfo;
17410 fn deref(&self) -> &Self::Target {
17411 &self.0
17412 }
17413}
17414impl<'a> std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> {
17415 fn deref_mut(&mut self) -> &mut Self::Target {
17416 &mut self.0
17417 }
17418}
17419#[doc(alias = "VkCommandBufferInheritanceInfo")]
17421#[derive(Copy, Clone)]
17422#[repr(C)]
17423pub struct CommandBufferInheritanceInfo {
17424 pub s_type: crate::vk1_0::StructureType,
17425 pub p_next: *const std::ffi::c_void,
17426 pub render_pass: crate::vk1_0::RenderPass,
17427 pub subpass: u32,
17428 pub framebuffer: crate::vk1_0::Framebuffer,
17429 pub occlusion_query_enable: crate::vk1_0::Bool32,
17430 pub query_flags: crate::vk1_0::QueryControlFlags,
17431 pub pipeline_statistics: crate::vk1_0::QueryPipelineStatisticFlags,
17432}
17433impl CommandBufferInheritanceInfo {
17434 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::COMMAND_BUFFER_INHERITANCE_INFO;
17435}
17436impl Default for CommandBufferInheritanceInfo {
17437 fn default() -> Self {
17438 Self {
17439 s_type: Self::STRUCTURE_TYPE,
17440 p_next: std::ptr::null(),
17441 render_pass: Default::default(),
17442 subpass: Default::default(),
17443 framebuffer: Default::default(),
17444 occlusion_query_enable: Default::default(),
17445 query_flags: Default::default(),
17446 pipeline_statistics: Default::default(),
17447 }
17448 }
17449}
17450impl std::fmt::Debug for CommandBufferInheritanceInfo {
17451 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17452 f.debug_struct("CommandBufferInheritanceInfo")
17453 .field("s_type", &self.s_type)
17454 .field("p_next", &self.p_next)
17455 .field("render_pass", &self.render_pass)
17456 .field("subpass", &self.subpass)
17457 .field("framebuffer", &self.framebuffer)
17458 .field("occlusion_query_enable", &(self.occlusion_query_enable != 0))
17459 .field("query_flags", &self.query_flags)
17460 .field("pipeline_statistics", &self.pipeline_statistics)
17461 .finish()
17462 }
17463}
17464impl CommandBufferInheritanceInfo {
17465 #[inline]
17466 pub fn into_builder<'a>(self) -> CommandBufferInheritanceInfoBuilder<'a> {
17467 CommandBufferInheritanceInfoBuilder(self, std::marker::PhantomData)
17468 }
17469}
17470#[derive(Copy, Clone)]
17471#[repr(transparent)]
17473pub struct CommandBufferInheritanceInfoBuilder<'a>(
17474 CommandBufferInheritanceInfo,
17475 std::marker::PhantomData<&'a ()>,
17476);
17477impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
17478 #[inline]
17479 pub fn new() -> CommandBufferInheritanceInfoBuilder<'a> {
17480 CommandBufferInheritanceInfoBuilder(Default::default(), std::marker::PhantomData)
17481 }
17482 #[inline]
17483 #[must_use]
17484 pub fn render_pass(mut self, render_pass: crate::vk1_0::RenderPass) -> Self {
17485 self.0.render_pass = render_pass as _;
17486 self
17487 }
17488 #[inline]
17489 #[must_use]
17490 pub fn subpass(mut self, subpass: u32) -> Self {
17491 self.0.subpass = subpass as _;
17492 self
17493 }
17494 #[inline]
17495 #[must_use]
17496 pub fn framebuffer(mut self, framebuffer: crate::vk1_0::Framebuffer) -> Self {
17497 self.0.framebuffer = framebuffer as _;
17498 self
17499 }
17500 #[inline]
17501 #[must_use]
17502 pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self {
17503 self.0.occlusion_query_enable = occlusion_query_enable as _;
17504 self
17505 }
17506 #[inline]
17507 #[must_use]
17508 pub fn query_flags(mut self, query_flags: crate::vk1_0::QueryControlFlags) -> Self {
17509 self.0.query_flags = query_flags as _;
17510 self
17511 }
17512 #[inline]
17513 #[must_use]
17514 pub fn pipeline_statistics(
17515 mut self,
17516 pipeline_statistics: crate::vk1_0::QueryPipelineStatisticFlags,
17517 ) -> Self {
17518 self.0.pipeline_statistics = pipeline_statistics as _;
17519 self
17520 }
17521 #[inline]
17522 pub fn build_dangling(self) -> CommandBufferInheritanceInfo {
17525 self.0
17526 }
17527}
17528impl<'a> std::default::Default for CommandBufferInheritanceInfoBuilder<'a> {
17529 fn default() -> CommandBufferInheritanceInfoBuilder<'a> {
17530 Self::new()
17531 }
17532}
17533impl<'a> std::fmt::Debug for CommandBufferInheritanceInfoBuilder<'a> {
17534 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17535 std::fmt::Debug::fmt(&self.0, f)
17536 }
17537}
17538impl<'a> std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> {
17539 type Target = CommandBufferInheritanceInfo;
17540 fn deref(&self) -> &Self::Target {
17541 &self.0
17542 }
17543}
17544impl<'a> std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> {
17545 fn deref_mut(&mut self) -> &mut Self::Target {
17546 &mut self.0
17547 }
17548}
17549#[doc(alias = "VkCommandBufferBeginInfo")]
17551#[derive(Copy, Clone)]
17552#[repr(C)]
17553pub struct CommandBufferBeginInfo {
17554 pub s_type: crate::vk1_0::StructureType,
17555 pub p_next: *const std::ffi::c_void,
17556 pub flags: crate::vk1_0::CommandBufferUsageFlags,
17557 pub p_inheritance_info: *const crate::vk1_0::CommandBufferInheritanceInfo,
17558}
17559impl CommandBufferBeginInfo {
17560 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::COMMAND_BUFFER_BEGIN_INFO;
17561}
17562impl Default for CommandBufferBeginInfo {
17563 fn default() -> Self {
17564 Self {
17565 s_type: Self::STRUCTURE_TYPE,
17566 p_next: std::ptr::null(),
17567 flags: Default::default(),
17568 p_inheritance_info: std::ptr::null(),
17569 }
17570 }
17571}
17572impl std::fmt::Debug for CommandBufferBeginInfo {
17573 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17574 f.debug_struct("CommandBufferBeginInfo")
17575 .field("s_type", &self.s_type)
17576 .field("p_next", &self.p_next)
17577 .field("flags", &self.flags)
17578 .field("p_inheritance_info", &self.p_inheritance_info)
17579 .finish()
17580 }
17581}
17582impl CommandBufferBeginInfo {
17583 #[inline]
17584 pub fn into_builder<'a>(self) -> CommandBufferBeginInfoBuilder<'a> {
17585 CommandBufferBeginInfoBuilder(self, std::marker::PhantomData)
17586 }
17587}
17588#[derive(Copy, Clone)]
17589#[repr(transparent)]
17591pub struct CommandBufferBeginInfoBuilder<'a>(
17592 CommandBufferBeginInfo,
17593 std::marker::PhantomData<&'a ()>,
17594);
17595impl<'a> CommandBufferBeginInfoBuilder<'a> {
17596 #[inline]
17597 pub fn new() -> CommandBufferBeginInfoBuilder<'a> {
17598 CommandBufferBeginInfoBuilder(Default::default(), std::marker::PhantomData)
17599 }
17600 #[inline]
17601 #[must_use]
17602 pub fn flags(mut self, flags: crate::vk1_0::CommandBufferUsageFlags) -> Self {
17603 self.0.flags = flags as _;
17604 self
17605 }
17606 #[inline]
17607 #[must_use]
17608 pub fn inheritance_info(
17609 mut self,
17610 inheritance_info: &'a crate::vk1_0::CommandBufferInheritanceInfo,
17611 ) -> Self {
17612 self.0.p_inheritance_info = inheritance_info as _;
17613 self
17614 }
17615 #[inline]
17616 pub fn build_dangling(self) -> CommandBufferBeginInfo {
17619 self.0
17620 }
17621}
17622impl<'a> std::default::Default for CommandBufferBeginInfoBuilder<'a> {
17623 fn default() -> CommandBufferBeginInfoBuilder<'a> {
17624 Self::new()
17625 }
17626}
17627impl<'a> std::fmt::Debug for CommandBufferBeginInfoBuilder<'a> {
17628 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17629 std::fmt::Debug::fmt(&self.0, f)
17630 }
17631}
17632impl<'a> std::ops::Deref for CommandBufferBeginInfoBuilder<'a> {
17633 type Target = CommandBufferBeginInfo;
17634 fn deref(&self) -> &Self::Target {
17635 &self.0
17636 }
17637}
17638impl<'a> std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> {
17639 fn deref_mut(&mut self) -> &mut Self::Target {
17640 &mut self.0
17641 }
17642}
17643#[doc(alias = "VkRenderPassBeginInfo")]
17645#[derive(Copy, Clone)]
17646#[repr(C)]
17647pub struct RenderPassBeginInfo {
17648 pub s_type: crate::vk1_0::StructureType,
17649 pub p_next: *const std::ffi::c_void,
17650 pub render_pass: crate::vk1_0::RenderPass,
17651 pub framebuffer: crate::vk1_0::Framebuffer,
17652 pub render_area: crate::vk1_0::Rect2D,
17653 pub clear_value_count: u32,
17654 pub p_clear_values: *const crate::vk1_0::ClearValue,
17655}
17656impl RenderPassBeginInfo {
17657 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::RENDER_PASS_BEGIN_INFO;
17658}
17659impl Default for RenderPassBeginInfo {
17660 fn default() -> Self {
17661 Self {
17662 s_type: Self::STRUCTURE_TYPE,
17663 p_next: std::ptr::null(),
17664 render_pass: Default::default(),
17665 framebuffer: Default::default(),
17666 render_area: Default::default(),
17667 clear_value_count: Default::default(),
17668 p_clear_values: std::ptr::null(),
17669 }
17670 }
17671}
17672impl std::fmt::Debug for RenderPassBeginInfo {
17673 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17674 f.debug_struct("RenderPassBeginInfo")
17675 .field("s_type", &self.s_type)
17676 .field("p_next", &self.p_next)
17677 .field("render_pass", &self.render_pass)
17678 .field("framebuffer", &self.framebuffer)
17679 .field("render_area", &self.render_area)
17680 .field("clear_value_count", &self.clear_value_count)
17681 .field("p_clear_values", &self.p_clear_values)
17682 .finish()
17683 }
17684}
17685impl RenderPassBeginInfo {
17686 #[inline]
17687 pub fn into_builder<'a>(self) -> RenderPassBeginInfoBuilder<'a> {
17688 RenderPassBeginInfoBuilder(self, std::marker::PhantomData)
17689 }
17690}
17691#[derive(Copy, Clone)]
17692#[repr(transparent)]
17694pub struct RenderPassBeginInfoBuilder<'a>(
17695 RenderPassBeginInfo,
17696 std::marker::PhantomData<&'a ()>,
17697);
17698impl<'a> RenderPassBeginInfoBuilder<'a> {
17699 #[inline]
17700 pub fn new() -> RenderPassBeginInfoBuilder<'a> {
17701 RenderPassBeginInfoBuilder(Default::default(), std::marker::PhantomData)
17702 }
17703 #[inline]
17704 #[must_use]
17705 pub fn render_pass(mut self, render_pass: crate::vk1_0::RenderPass) -> Self {
17706 self.0.render_pass = render_pass as _;
17707 self
17708 }
17709 #[inline]
17710 #[must_use]
17711 pub fn framebuffer(mut self, framebuffer: crate::vk1_0::Framebuffer) -> Self {
17712 self.0.framebuffer = framebuffer as _;
17713 self
17714 }
17715 #[inline]
17716 #[must_use]
17717 pub fn render_area(mut self, render_area: crate::vk1_0::Rect2D) -> Self {
17718 self.0.render_area = render_area as _;
17719 self
17720 }
17721 #[inline]
17722 #[must_use]
17723 pub fn clear_values(mut self, clear_values: &'a [crate::vk1_0::ClearValue]) -> Self {
17724 self.0.p_clear_values = clear_values.as_ptr() as _;
17725 self.0.clear_value_count = clear_values.len() as _;
17726 self
17727 }
17728 #[inline]
17729 pub fn build_dangling(self) -> RenderPassBeginInfo {
17732 self.0
17733 }
17734}
17735impl<'a> std::default::Default for RenderPassBeginInfoBuilder<'a> {
17736 fn default() -> RenderPassBeginInfoBuilder<'a> {
17737 Self::new()
17738 }
17739}
17740impl<'a> std::fmt::Debug for RenderPassBeginInfoBuilder<'a> {
17741 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17742 std::fmt::Debug::fmt(&self.0, f)
17743 }
17744}
17745impl<'a> std::ops::Deref for RenderPassBeginInfoBuilder<'a> {
17746 type Target = RenderPassBeginInfo;
17747 fn deref(&self) -> &Self::Target {
17748 &self.0
17749 }
17750}
17751impl<'a> std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> {
17752 fn deref_mut(&mut self) -> &mut Self::Target {
17753 &mut self.0
17754 }
17755}
17756#[doc(alias = "VkClearColorValue")]
17758#[derive(Copy, Clone)]
17759#[repr(C)]
17760pub union ClearColorValue {
17761 pub float32: [std::os::raw::c_float; 4],
17762 pub int32: [i32; 4],
17763 pub uint32: [u32; 4],
17764}
17765impl Default for ClearColorValue {
17766 fn default() -> Self {
17767 unsafe { std::mem::zeroed() }
17768 }
17769}
17770impl std::fmt::Debug for ClearColorValue {
17771 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17772 f.debug_struct("ClearColorValue").finish()
17773 }
17774}
17775#[doc(alias = "VkClearDepthStencilValue")]
17777#[derive(Copy, Clone)]
17778#[repr(C)]
17779pub struct ClearDepthStencilValue {
17780 pub depth: std::os::raw::c_float,
17781 pub stencil: u32,
17782}
17783impl Default for ClearDepthStencilValue {
17784 fn default() -> Self {
17785 Self {
17786 depth: Default::default(),
17787 stencil: Default::default(),
17788 }
17789 }
17790}
17791impl std::fmt::Debug for ClearDepthStencilValue {
17792 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17793 f.debug_struct("ClearDepthStencilValue")
17794 .field("depth", &self.depth)
17795 .field("stencil", &self.stencil)
17796 .finish()
17797 }
17798}
17799impl ClearDepthStencilValue {
17800 #[inline]
17801 pub fn into_builder<'a>(self) -> ClearDepthStencilValueBuilder<'a> {
17802 ClearDepthStencilValueBuilder(self, std::marker::PhantomData)
17803 }
17804}
17805#[derive(Copy, Clone)]
17806#[repr(transparent)]
17808pub struct ClearDepthStencilValueBuilder<'a>(
17809 ClearDepthStencilValue,
17810 std::marker::PhantomData<&'a ()>,
17811);
17812impl<'a> ClearDepthStencilValueBuilder<'a> {
17813 #[inline]
17814 pub fn new() -> ClearDepthStencilValueBuilder<'a> {
17815 ClearDepthStencilValueBuilder(Default::default(), std::marker::PhantomData)
17816 }
17817 #[inline]
17818 #[must_use]
17819 pub fn depth(mut self, depth: std::os::raw::c_float) -> Self {
17820 self.0.depth = depth as _;
17821 self
17822 }
17823 #[inline]
17824 #[must_use]
17825 pub fn stencil(mut self, stencil: u32) -> Self {
17826 self.0.stencil = stencil as _;
17827 self
17828 }
17829 #[inline]
17830 pub fn build(self) -> ClearDepthStencilValue {
17831 self.0
17832 }
17833}
17834impl<'a> std::default::Default for ClearDepthStencilValueBuilder<'a> {
17835 fn default() -> ClearDepthStencilValueBuilder<'a> {
17836 Self::new()
17837 }
17838}
17839impl<'a> std::fmt::Debug for ClearDepthStencilValueBuilder<'a> {
17840 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17841 std::fmt::Debug::fmt(&self.0, f)
17842 }
17843}
17844impl<'a> std::ops::Deref for ClearDepthStencilValueBuilder<'a> {
17845 type Target = ClearDepthStencilValue;
17846 fn deref(&self) -> &Self::Target {
17847 &self.0
17848 }
17849}
17850impl<'a> std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> {
17851 fn deref_mut(&mut self) -> &mut Self::Target {
17852 &mut self.0
17853 }
17854}
17855#[doc(alias = "VkClearValue")]
17857#[derive(Copy, Clone)]
17858#[repr(C)]
17859pub union ClearValue {
17860 pub color: crate::vk1_0::ClearColorValue,
17861 pub depth_stencil: crate::vk1_0::ClearDepthStencilValue,
17862}
17863impl Default for ClearValue {
17864 fn default() -> Self {
17865 unsafe { std::mem::zeroed() }
17866 }
17867}
17868impl std::fmt::Debug for ClearValue {
17869 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17870 f.debug_struct("ClearValue").finish()
17871 }
17872}
17873#[doc(alias = "VkClearAttachment")]
17875#[derive(Copy, Clone)]
17876#[repr(C)]
17877pub struct ClearAttachment {
17878 pub aspect_mask: crate::vk1_0::ImageAspectFlags,
17879 pub color_attachment: u32,
17880 pub clear_value: crate::vk1_0::ClearValue,
17881}
17882impl Default for ClearAttachment {
17883 fn default() -> Self {
17884 Self {
17885 aspect_mask: Default::default(),
17886 color_attachment: Default::default(),
17887 clear_value: Default::default(),
17888 }
17889 }
17890}
17891impl std::fmt::Debug for ClearAttachment {
17892 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17893 f.debug_struct("ClearAttachment")
17894 .field("aspect_mask", &self.aspect_mask)
17895 .field("color_attachment", &self.color_attachment)
17896 .field("clear_value", &self.clear_value)
17897 .finish()
17898 }
17899}
17900impl ClearAttachment {
17901 #[inline]
17902 pub fn into_builder<'a>(self) -> ClearAttachmentBuilder<'a> {
17903 ClearAttachmentBuilder(self, std::marker::PhantomData)
17904 }
17905}
17906#[derive(Copy, Clone)]
17907#[repr(transparent)]
17909pub struct ClearAttachmentBuilder<'a>(ClearAttachment, std::marker::PhantomData<&'a ()>);
17910impl<'a> ClearAttachmentBuilder<'a> {
17911 #[inline]
17912 pub fn new() -> ClearAttachmentBuilder<'a> {
17913 ClearAttachmentBuilder(Default::default(), std::marker::PhantomData)
17914 }
17915 #[inline]
17916 #[must_use]
17917 pub fn aspect_mask(mut self, aspect_mask: crate::vk1_0::ImageAspectFlags) -> Self {
17918 self.0.aspect_mask = aspect_mask as _;
17919 self
17920 }
17921 #[inline]
17922 #[must_use]
17923 pub fn color_attachment(mut self, color_attachment: u32) -> Self {
17924 self.0.color_attachment = color_attachment as _;
17925 self
17926 }
17927 #[inline]
17928 #[must_use]
17929 pub fn clear_value(mut self, clear_value: crate::vk1_0::ClearValue) -> Self {
17930 self.0.clear_value = clear_value as _;
17931 self
17932 }
17933 #[inline]
17934 pub fn build(self) -> ClearAttachment {
17935 self.0
17936 }
17937}
17938impl<'a> std::default::Default for ClearAttachmentBuilder<'a> {
17939 fn default() -> ClearAttachmentBuilder<'a> {
17940 Self::new()
17941 }
17942}
17943impl<'a> std::fmt::Debug for ClearAttachmentBuilder<'a> {
17944 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17945 std::fmt::Debug::fmt(&self.0, f)
17946 }
17947}
17948impl<'a> std::ops::Deref for ClearAttachmentBuilder<'a> {
17949 type Target = ClearAttachment;
17950 fn deref(&self) -> &Self::Target {
17951 &self.0
17952 }
17953}
17954impl<'a> std::ops::DerefMut for ClearAttachmentBuilder<'a> {
17955 fn deref_mut(&mut self) -> &mut Self::Target {
17956 &mut self.0
17957 }
17958}
17959#[doc(alias = "VkAttachmentDescription")]
17961#[derive(Copy, Clone, Hash, PartialEq, Eq)]
17962#[repr(C)]
17963pub struct AttachmentDescription {
17964 pub flags: crate::vk1_0::AttachmentDescriptionFlags,
17965 pub format: crate::vk1_0::Format,
17966 pub samples: crate::vk1_0::SampleCountFlagBits,
17967 pub load_op: crate::vk1_0::AttachmentLoadOp,
17968 pub store_op: crate::vk1_0::AttachmentStoreOp,
17969 pub stencil_load_op: crate::vk1_0::AttachmentLoadOp,
17970 pub stencil_store_op: crate::vk1_0::AttachmentStoreOp,
17971 pub initial_layout: crate::vk1_0::ImageLayout,
17972 pub final_layout: crate::vk1_0::ImageLayout,
17973}
17974impl Default for AttachmentDescription {
17975 fn default() -> Self {
17976 Self {
17977 flags: Default::default(),
17978 format: Default::default(),
17979 samples: Default::default(),
17980 load_op: Default::default(),
17981 store_op: Default::default(),
17982 stencil_load_op: Default::default(),
17983 stencil_store_op: Default::default(),
17984 initial_layout: Default::default(),
17985 final_layout: Default::default(),
17986 }
17987 }
17988}
17989impl std::fmt::Debug for AttachmentDescription {
17990 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
17991 f.debug_struct("AttachmentDescription")
17992 .field("flags", &self.flags)
17993 .field("format", &self.format)
17994 .field("samples", &self.samples)
17995 .field("load_op", &self.load_op)
17996 .field("store_op", &self.store_op)
17997 .field("stencil_load_op", &self.stencil_load_op)
17998 .field("stencil_store_op", &self.stencil_store_op)
17999 .field("initial_layout", &self.initial_layout)
18000 .field("final_layout", &self.final_layout)
18001 .finish()
18002 }
18003}
18004impl AttachmentDescription {
18005 #[inline]
18006 pub fn into_builder<'a>(self) -> AttachmentDescriptionBuilder<'a> {
18007 AttachmentDescriptionBuilder(self, std::marker::PhantomData)
18008 }
18009}
18010#[derive(Copy, Clone)]
18011#[repr(transparent)]
18013pub struct AttachmentDescriptionBuilder<'a>(
18014 AttachmentDescription,
18015 std::marker::PhantomData<&'a ()>,
18016);
18017impl<'a> AttachmentDescriptionBuilder<'a> {
18018 #[inline]
18019 pub fn new() -> AttachmentDescriptionBuilder<'a> {
18020 AttachmentDescriptionBuilder(Default::default(), std::marker::PhantomData)
18021 }
18022 #[inline]
18023 #[must_use]
18024 pub fn flags(mut self, flags: crate::vk1_0::AttachmentDescriptionFlags) -> Self {
18025 self.0.flags = flags as _;
18026 self
18027 }
18028 #[inline]
18029 #[must_use]
18030 pub fn format(mut self, format: crate::vk1_0::Format) -> Self {
18031 self.0.format = format as _;
18032 self
18033 }
18034 #[inline]
18035 #[must_use]
18036 pub fn samples(mut self, samples: crate::vk1_0::SampleCountFlagBits) -> Self {
18037 self.0.samples = samples as _;
18038 self
18039 }
18040 #[inline]
18041 #[must_use]
18042 pub fn load_op(mut self, load_op: crate::vk1_0::AttachmentLoadOp) -> Self {
18043 self.0.load_op = load_op as _;
18044 self
18045 }
18046 #[inline]
18047 #[must_use]
18048 pub fn store_op(mut self, store_op: crate::vk1_0::AttachmentStoreOp) -> Self {
18049 self.0.store_op = store_op as _;
18050 self
18051 }
18052 #[inline]
18053 #[must_use]
18054 pub fn stencil_load_op(
18055 mut self,
18056 stencil_load_op: crate::vk1_0::AttachmentLoadOp,
18057 ) -> Self {
18058 self.0.stencil_load_op = stencil_load_op as _;
18059 self
18060 }
18061 #[inline]
18062 #[must_use]
18063 pub fn stencil_store_op(
18064 mut self,
18065 stencil_store_op: crate::vk1_0::AttachmentStoreOp,
18066 ) -> Self {
18067 self.0.stencil_store_op = stencil_store_op as _;
18068 self
18069 }
18070 #[inline]
18071 #[must_use]
18072 pub fn initial_layout(mut self, initial_layout: crate::vk1_0::ImageLayout) -> Self {
18073 self.0.initial_layout = initial_layout as _;
18074 self
18075 }
18076 #[inline]
18077 #[must_use]
18078 pub fn final_layout(mut self, final_layout: crate::vk1_0::ImageLayout) -> Self {
18079 self.0.final_layout = final_layout as _;
18080 self
18081 }
18082 #[inline]
18083 pub fn build(self) -> AttachmentDescription {
18084 self.0
18085 }
18086}
18087impl<'a> std::default::Default for AttachmentDescriptionBuilder<'a> {
18088 fn default() -> AttachmentDescriptionBuilder<'a> {
18089 Self::new()
18090 }
18091}
18092impl<'a> std::fmt::Debug for AttachmentDescriptionBuilder<'a> {
18093 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18094 std::fmt::Debug::fmt(&self.0, f)
18095 }
18096}
18097impl<'a> std::ops::Deref for AttachmentDescriptionBuilder<'a> {
18098 type Target = AttachmentDescription;
18099 fn deref(&self) -> &Self::Target {
18100 &self.0
18101 }
18102}
18103impl<'a> std::ops::DerefMut for AttachmentDescriptionBuilder<'a> {
18104 fn deref_mut(&mut self) -> &mut Self::Target {
18105 &mut self.0
18106 }
18107}
18108#[doc(alias = "VkAttachmentReference")]
18110#[derive(Copy, Clone, Hash, PartialEq, Eq)]
18111#[repr(C)]
18112pub struct AttachmentReference {
18113 pub attachment: u32,
18114 pub layout: crate::vk1_0::ImageLayout,
18115}
18116impl Default for AttachmentReference {
18117 fn default() -> Self {
18118 Self {
18119 attachment: Default::default(),
18120 layout: Default::default(),
18121 }
18122 }
18123}
18124impl std::fmt::Debug for AttachmentReference {
18125 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18126 f.debug_struct("AttachmentReference")
18127 .field("attachment", &self.attachment)
18128 .field("layout", &self.layout)
18129 .finish()
18130 }
18131}
18132impl AttachmentReference {
18133 #[inline]
18134 pub fn into_builder<'a>(self) -> AttachmentReferenceBuilder<'a> {
18135 AttachmentReferenceBuilder(self, std::marker::PhantomData)
18136 }
18137}
18138#[derive(Copy, Clone)]
18139#[repr(transparent)]
18141pub struct AttachmentReferenceBuilder<'a>(
18142 AttachmentReference,
18143 std::marker::PhantomData<&'a ()>,
18144);
18145impl<'a> AttachmentReferenceBuilder<'a> {
18146 #[inline]
18147 pub fn new() -> AttachmentReferenceBuilder<'a> {
18148 AttachmentReferenceBuilder(Default::default(), std::marker::PhantomData)
18149 }
18150 #[inline]
18151 #[must_use]
18152 pub fn attachment(mut self, attachment: u32) -> Self {
18153 self.0.attachment = attachment as _;
18154 self
18155 }
18156 #[inline]
18157 #[must_use]
18158 pub fn layout(mut self, layout: crate::vk1_0::ImageLayout) -> Self {
18159 self.0.layout = layout as _;
18160 self
18161 }
18162 #[inline]
18163 pub fn build(self) -> AttachmentReference {
18164 self.0
18165 }
18166}
18167impl<'a> std::default::Default for AttachmentReferenceBuilder<'a> {
18168 fn default() -> AttachmentReferenceBuilder<'a> {
18169 Self::new()
18170 }
18171}
18172impl<'a> std::fmt::Debug for AttachmentReferenceBuilder<'a> {
18173 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18174 std::fmt::Debug::fmt(&self.0, f)
18175 }
18176}
18177impl<'a> std::ops::Deref for AttachmentReferenceBuilder<'a> {
18178 type Target = AttachmentReference;
18179 fn deref(&self) -> &Self::Target {
18180 &self.0
18181 }
18182}
18183impl<'a> std::ops::DerefMut for AttachmentReferenceBuilder<'a> {
18184 fn deref_mut(&mut self) -> &mut Self::Target {
18185 &mut self.0
18186 }
18187}
18188#[doc(alias = "VkSubpassDescription")]
18190#[derive(Copy, Clone)]
18191#[repr(C)]
18192pub struct SubpassDescription {
18193 pub flags: crate::vk1_0::SubpassDescriptionFlags,
18194 pub pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
18195 pub input_attachment_count: u32,
18196 pub p_input_attachments: *const crate::vk1_0::AttachmentReference,
18197 pub color_attachment_count: u32,
18198 pub p_color_attachments: *const crate::vk1_0::AttachmentReference,
18199 pub p_resolve_attachments: *const crate::vk1_0::AttachmentReference,
18200 pub p_depth_stencil_attachment: *const crate::vk1_0::AttachmentReference,
18201 pub preserve_attachment_count: u32,
18202 pub p_preserve_attachments: *const u32,
18203}
18204impl Default for SubpassDescription {
18205 fn default() -> Self {
18206 Self {
18207 flags: Default::default(),
18208 pipeline_bind_point: Default::default(),
18209 input_attachment_count: Default::default(),
18210 p_input_attachments: std::ptr::null(),
18211 color_attachment_count: Default::default(),
18212 p_color_attachments: std::ptr::null(),
18213 p_resolve_attachments: std::ptr::null(),
18214 p_depth_stencil_attachment: std::ptr::null(),
18215 preserve_attachment_count: Default::default(),
18216 p_preserve_attachments: std::ptr::null(),
18217 }
18218 }
18219}
18220impl std::fmt::Debug for SubpassDescription {
18221 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18222 f.debug_struct("SubpassDescription")
18223 .field("flags", &self.flags)
18224 .field("pipeline_bind_point", &self.pipeline_bind_point)
18225 .field("input_attachment_count", &self.input_attachment_count)
18226 .field("p_input_attachments", &self.p_input_attachments)
18227 .field("color_attachment_count", &self.color_attachment_count)
18228 .field("p_color_attachments", &self.p_color_attachments)
18229 .field("p_resolve_attachments", &self.p_resolve_attachments)
18230 .field("p_depth_stencil_attachment", &self.p_depth_stencil_attachment)
18231 .field("preserve_attachment_count", &self.preserve_attachment_count)
18232 .field("p_preserve_attachments", &self.p_preserve_attachments)
18233 .finish()
18234 }
18235}
18236impl SubpassDescription {
18237 #[inline]
18238 pub fn into_builder<'a>(self) -> SubpassDescriptionBuilder<'a> {
18239 SubpassDescriptionBuilder(self, std::marker::PhantomData)
18240 }
18241}
18242#[derive(Copy, Clone)]
18243#[repr(transparent)]
18245pub struct SubpassDescriptionBuilder<'a>(
18246 SubpassDescription,
18247 std::marker::PhantomData<&'a ()>,
18248);
18249impl<'a> SubpassDescriptionBuilder<'a> {
18250 #[inline]
18251 pub fn new() -> SubpassDescriptionBuilder<'a> {
18252 SubpassDescriptionBuilder(Default::default(), std::marker::PhantomData)
18253 }
18254 #[inline]
18255 #[must_use]
18256 pub fn flags(mut self, flags: crate::vk1_0::SubpassDescriptionFlags) -> Self {
18257 self.0.flags = flags as _;
18258 self
18259 }
18260 #[inline]
18261 #[must_use]
18262 pub fn pipeline_bind_point(
18263 mut self,
18264 pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
18265 ) -> Self {
18266 self.0.pipeline_bind_point = pipeline_bind_point as _;
18267 self
18268 }
18269 #[inline]
18270 #[must_use]
18271 pub fn input_attachments(
18272 mut self,
18273 input_attachments: &'a [crate::vk1_0::AttachmentReferenceBuilder],
18274 ) -> Self {
18275 self.0.p_input_attachments = input_attachments.as_ptr() as _;
18276 self.0.input_attachment_count = input_attachments.len() as _;
18277 self
18278 }
18279 #[inline]
18280 #[must_use]
18281 pub fn color_attachments(
18282 mut self,
18283 color_attachments: &'a [crate::vk1_0::AttachmentReferenceBuilder],
18284 ) -> Self {
18285 self.0.p_color_attachments = color_attachments.as_ptr() as _;
18286 self.0.color_attachment_count = color_attachments.len() as _;
18287 self
18288 }
18289 #[inline]
18290 #[must_use]
18291 pub fn resolve_attachments(
18292 mut self,
18293 resolve_attachments: &'a [crate::vk1_0::AttachmentReferenceBuilder],
18294 ) -> Self {
18295 self.0.p_resolve_attachments = resolve_attachments.as_ptr() as _;
18296 self.0.color_attachment_count = resolve_attachments.len() as _;
18297 self
18298 }
18299 #[inline]
18300 #[must_use]
18301 pub fn depth_stencil_attachment(
18302 mut self,
18303 depth_stencil_attachment: &'a crate::vk1_0::AttachmentReference,
18304 ) -> Self {
18305 self.0.p_depth_stencil_attachment = depth_stencil_attachment as _;
18306 self
18307 }
18308 #[inline]
18309 #[must_use]
18310 pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
18311 self.0.p_preserve_attachments = preserve_attachments.as_ptr() as _;
18312 self.0.preserve_attachment_count = preserve_attachments.len() as _;
18313 self
18314 }
18315 #[inline]
18316 pub fn build_dangling(self) -> SubpassDescription {
18319 self.0
18320 }
18321}
18322impl<'a> std::default::Default for SubpassDescriptionBuilder<'a> {
18323 fn default() -> SubpassDescriptionBuilder<'a> {
18324 Self::new()
18325 }
18326}
18327impl<'a> std::fmt::Debug for SubpassDescriptionBuilder<'a> {
18328 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18329 std::fmt::Debug::fmt(&self.0, f)
18330 }
18331}
18332impl<'a> std::ops::Deref for SubpassDescriptionBuilder<'a> {
18333 type Target = SubpassDescription;
18334 fn deref(&self) -> &Self::Target {
18335 &self.0
18336 }
18337}
18338impl<'a> std::ops::DerefMut for SubpassDescriptionBuilder<'a> {
18339 fn deref_mut(&mut self) -> &mut Self::Target {
18340 &mut self.0
18341 }
18342}
18343#[doc(alias = "VkSubpassDependency")]
18345#[derive(Copy, Clone, Hash, PartialEq, Eq)]
18346#[repr(C)]
18347pub struct SubpassDependency {
18348 pub src_subpass: u32,
18349 pub dst_subpass: u32,
18350 pub src_stage_mask: crate::vk1_0::PipelineStageFlags,
18351 pub dst_stage_mask: crate::vk1_0::PipelineStageFlags,
18352 pub src_access_mask: crate::vk1_0::AccessFlags,
18353 pub dst_access_mask: crate::vk1_0::AccessFlags,
18354 pub dependency_flags: crate::vk1_0::DependencyFlags,
18355}
18356impl Default for SubpassDependency {
18357 fn default() -> Self {
18358 Self {
18359 src_subpass: Default::default(),
18360 dst_subpass: Default::default(),
18361 src_stage_mask: Default::default(),
18362 dst_stage_mask: Default::default(),
18363 src_access_mask: Default::default(),
18364 dst_access_mask: Default::default(),
18365 dependency_flags: Default::default(),
18366 }
18367 }
18368}
18369impl std::fmt::Debug for SubpassDependency {
18370 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18371 f.debug_struct("SubpassDependency")
18372 .field("src_subpass", &self.src_subpass)
18373 .field("dst_subpass", &self.dst_subpass)
18374 .field("src_stage_mask", &self.src_stage_mask)
18375 .field("dst_stage_mask", &self.dst_stage_mask)
18376 .field("src_access_mask", &self.src_access_mask)
18377 .field("dst_access_mask", &self.dst_access_mask)
18378 .field("dependency_flags", &self.dependency_flags)
18379 .finish()
18380 }
18381}
18382impl SubpassDependency {
18383 #[inline]
18384 pub fn into_builder<'a>(self) -> SubpassDependencyBuilder<'a> {
18385 SubpassDependencyBuilder(self, std::marker::PhantomData)
18386 }
18387}
18388#[derive(Copy, Clone)]
18389#[repr(transparent)]
18391pub struct SubpassDependencyBuilder<'a>(
18392 SubpassDependency,
18393 std::marker::PhantomData<&'a ()>,
18394);
18395impl<'a> SubpassDependencyBuilder<'a> {
18396 #[inline]
18397 pub fn new() -> SubpassDependencyBuilder<'a> {
18398 SubpassDependencyBuilder(Default::default(), std::marker::PhantomData)
18399 }
18400 #[inline]
18401 #[must_use]
18402 pub fn src_subpass(mut self, src_subpass: u32) -> Self {
18403 self.0.src_subpass = src_subpass as _;
18404 self
18405 }
18406 #[inline]
18407 #[must_use]
18408 pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
18409 self.0.dst_subpass = dst_subpass as _;
18410 self
18411 }
18412 #[inline]
18413 #[must_use]
18414 pub fn src_stage_mask(
18415 mut self,
18416 src_stage_mask: crate::vk1_0::PipelineStageFlags,
18417 ) -> Self {
18418 self.0.src_stage_mask = src_stage_mask as _;
18419 self
18420 }
18421 #[inline]
18422 #[must_use]
18423 pub fn dst_stage_mask(
18424 mut self,
18425 dst_stage_mask: crate::vk1_0::PipelineStageFlags,
18426 ) -> Self {
18427 self.0.dst_stage_mask = dst_stage_mask as _;
18428 self
18429 }
18430 #[inline]
18431 #[must_use]
18432 pub fn src_access_mask(
18433 mut self,
18434 src_access_mask: crate::vk1_0::AccessFlags,
18435 ) -> Self {
18436 self.0.src_access_mask = src_access_mask as _;
18437 self
18438 }
18439 #[inline]
18440 #[must_use]
18441 pub fn dst_access_mask(
18442 mut self,
18443 dst_access_mask: crate::vk1_0::AccessFlags,
18444 ) -> Self {
18445 self.0.dst_access_mask = dst_access_mask as _;
18446 self
18447 }
18448 #[inline]
18449 #[must_use]
18450 pub fn dependency_flags(
18451 mut self,
18452 dependency_flags: crate::vk1_0::DependencyFlags,
18453 ) -> Self {
18454 self.0.dependency_flags = dependency_flags as _;
18455 self
18456 }
18457 #[inline]
18458 pub fn build(self) -> SubpassDependency {
18459 self.0
18460 }
18461}
18462impl<'a> std::default::Default for SubpassDependencyBuilder<'a> {
18463 fn default() -> SubpassDependencyBuilder<'a> {
18464 Self::new()
18465 }
18466}
18467impl<'a> std::fmt::Debug for SubpassDependencyBuilder<'a> {
18468 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18469 std::fmt::Debug::fmt(&self.0, f)
18470 }
18471}
18472impl<'a> std::ops::Deref for SubpassDependencyBuilder<'a> {
18473 type Target = SubpassDependency;
18474 fn deref(&self) -> &Self::Target {
18475 &self.0
18476 }
18477}
18478impl<'a> std::ops::DerefMut for SubpassDependencyBuilder<'a> {
18479 fn deref_mut(&mut self) -> &mut Self::Target {
18480 &mut self.0
18481 }
18482}
18483#[doc(alias = "VkRenderPassCreateInfo")]
18485#[derive(Copy, Clone)]
18486#[repr(C)]
18487pub struct RenderPassCreateInfo {
18488 pub s_type: crate::vk1_0::StructureType,
18489 pub p_next: *const std::ffi::c_void,
18490 pub flags: crate::vk1_0::RenderPassCreateFlags,
18491 pub attachment_count: u32,
18492 pub p_attachments: *const crate::vk1_0::AttachmentDescription,
18493 pub subpass_count: u32,
18494 pub p_subpasses: *const crate::vk1_0::SubpassDescription,
18495 pub dependency_count: u32,
18496 pub p_dependencies: *const crate::vk1_0::SubpassDependency,
18497}
18498impl RenderPassCreateInfo {
18499 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::RENDER_PASS_CREATE_INFO;
18500}
18501impl Default for RenderPassCreateInfo {
18502 fn default() -> Self {
18503 Self {
18504 s_type: Self::STRUCTURE_TYPE,
18505 p_next: std::ptr::null(),
18506 flags: Default::default(),
18507 attachment_count: Default::default(),
18508 p_attachments: std::ptr::null(),
18509 subpass_count: Default::default(),
18510 p_subpasses: std::ptr::null(),
18511 dependency_count: Default::default(),
18512 p_dependencies: std::ptr::null(),
18513 }
18514 }
18515}
18516impl std::fmt::Debug for RenderPassCreateInfo {
18517 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18518 f.debug_struct("RenderPassCreateInfo")
18519 .field("s_type", &self.s_type)
18520 .field("p_next", &self.p_next)
18521 .field("flags", &self.flags)
18522 .field("attachment_count", &self.attachment_count)
18523 .field("p_attachments", &self.p_attachments)
18524 .field("subpass_count", &self.subpass_count)
18525 .field("p_subpasses", &self.p_subpasses)
18526 .field("dependency_count", &self.dependency_count)
18527 .field("p_dependencies", &self.p_dependencies)
18528 .finish()
18529 }
18530}
18531impl RenderPassCreateInfo {
18532 #[inline]
18533 pub fn into_builder<'a>(self) -> RenderPassCreateInfoBuilder<'a> {
18534 RenderPassCreateInfoBuilder(self, std::marker::PhantomData)
18535 }
18536}
18537#[derive(Copy, Clone)]
18538#[repr(transparent)]
18540pub struct RenderPassCreateInfoBuilder<'a>(
18541 RenderPassCreateInfo,
18542 std::marker::PhantomData<&'a ()>,
18543);
18544impl<'a> RenderPassCreateInfoBuilder<'a> {
18545 #[inline]
18546 pub fn new() -> RenderPassCreateInfoBuilder<'a> {
18547 RenderPassCreateInfoBuilder(Default::default(), std::marker::PhantomData)
18548 }
18549 #[inline]
18550 #[must_use]
18551 pub fn flags(mut self, flags: crate::vk1_0::RenderPassCreateFlags) -> Self {
18552 self.0.flags = flags as _;
18553 self
18554 }
18555 #[inline]
18556 #[must_use]
18557 pub fn attachments(
18558 mut self,
18559 attachments: &'a [crate::vk1_0::AttachmentDescriptionBuilder],
18560 ) -> Self {
18561 self.0.p_attachments = attachments.as_ptr() as _;
18562 self.0.attachment_count = attachments.len() as _;
18563 self
18564 }
18565 #[inline]
18566 #[must_use]
18567 pub fn subpasses(
18568 mut self,
18569 subpasses: &'a [crate::vk1_0::SubpassDescriptionBuilder],
18570 ) -> Self {
18571 self.0.p_subpasses = subpasses.as_ptr() as _;
18572 self.0.subpass_count = subpasses.len() as _;
18573 self
18574 }
18575 #[inline]
18576 #[must_use]
18577 pub fn dependencies(
18578 mut self,
18579 dependencies: &'a [crate::vk1_0::SubpassDependencyBuilder],
18580 ) -> Self {
18581 self.0.p_dependencies = dependencies.as_ptr() as _;
18582 self.0.dependency_count = dependencies.len() as _;
18583 self
18584 }
18585 #[inline]
18586 pub fn build_dangling(self) -> RenderPassCreateInfo {
18589 self.0
18590 }
18591}
18592impl<'a> std::default::Default for RenderPassCreateInfoBuilder<'a> {
18593 fn default() -> RenderPassCreateInfoBuilder<'a> {
18594 Self::new()
18595 }
18596}
18597impl<'a> std::fmt::Debug for RenderPassCreateInfoBuilder<'a> {
18598 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18599 std::fmt::Debug::fmt(&self.0, f)
18600 }
18601}
18602impl<'a> std::ops::Deref for RenderPassCreateInfoBuilder<'a> {
18603 type Target = RenderPassCreateInfo;
18604 fn deref(&self) -> &Self::Target {
18605 &self.0
18606 }
18607}
18608impl<'a> std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> {
18609 fn deref_mut(&mut self) -> &mut Self::Target {
18610 &mut self.0
18611 }
18612}
18613#[doc(alias = "VkEventCreateInfo")]
18615#[derive(Copy, Clone)]
18616#[repr(C)]
18617pub struct EventCreateInfo {
18618 pub s_type: crate::vk1_0::StructureType,
18619 pub p_next: *const std::ffi::c_void,
18620 pub flags: crate::vk1_0::EventCreateFlags,
18621}
18622impl EventCreateInfo {
18623 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::EVENT_CREATE_INFO;
18624}
18625impl Default for EventCreateInfo {
18626 fn default() -> Self {
18627 Self {
18628 s_type: Self::STRUCTURE_TYPE,
18629 p_next: std::ptr::null(),
18630 flags: Default::default(),
18631 }
18632 }
18633}
18634impl std::fmt::Debug for EventCreateInfo {
18635 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18636 f.debug_struct("EventCreateInfo")
18637 .field("s_type", &self.s_type)
18638 .field("p_next", &self.p_next)
18639 .field("flags", &self.flags)
18640 .finish()
18641 }
18642}
18643impl EventCreateInfo {
18644 #[inline]
18645 pub fn into_builder<'a>(self) -> EventCreateInfoBuilder<'a> {
18646 EventCreateInfoBuilder(self, std::marker::PhantomData)
18647 }
18648}
18649#[derive(Copy, Clone)]
18650#[repr(transparent)]
18652pub struct EventCreateInfoBuilder<'a>(EventCreateInfo, std::marker::PhantomData<&'a ()>);
18653impl<'a> EventCreateInfoBuilder<'a> {
18654 #[inline]
18655 pub fn new() -> EventCreateInfoBuilder<'a> {
18656 EventCreateInfoBuilder(Default::default(), std::marker::PhantomData)
18657 }
18658 #[inline]
18659 #[must_use]
18660 pub fn flags(mut self, flags: crate::vk1_0::EventCreateFlags) -> Self {
18661 self.0.flags = flags as _;
18662 self
18663 }
18664 #[inline]
18665 pub fn build_dangling(self) -> EventCreateInfo {
18668 self.0
18669 }
18670}
18671impl<'a> std::default::Default for EventCreateInfoBuilder<'a> {
18672 fn default() -> EventCreateInfoBuilder<'a> {
18673 Self::new()
18674 }
18675}
18676impl<'a> std::fmt::Debug for EventCreateInfoBuilder<'a> {
18677 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18678 std::fmt::Debug::fmt(&self.0, f)
18679 }
18680}
18681impl<'a> std::ops::Deref for EventCreateInfoBuilder<'a> {
18682 type Target = EventCreateInfo;
18683 fn deref(&self) -> &Self::Target {
18684 &self.0
18685 }
18686}
18687impl<'a> std::ops::DerefMut for EventCreateInfoBuilder<'a> {
18688 fn deref_mut(&mut self) -> &mut Self::Target {
18689 &mut self.0
18690 }
18691}
18692#[doc(alias = "VkFenceCreateInfo")]
18694#[derive(Copy, Clone)]
18695#[repr(C)]
18696pub struct FenceCreateInfo {
18697 pub s_type: crate::vk1_0::StructureType,
18698 pub p_next: *const std::ffi::c_void,
18699 pub flags: crate::vk1_0::FenceCreateFlags,
18700}
18701impl FenceCreateInfo {
18702 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::FENCE_CREATE_INFO;
18703}
18704impl Default for FenceCreateInfo {
18705 fn default() -> Self {
18706 Self {
18707 s_type: Self::STRUCTURE_TYPE,
18708 p_next: std::ptr::null(),
18709 flags: Default::default(),
18710 }
18711 }
18712}
18713impl std::fmt::Debug for FenceCreateInfo {
18714 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18715 f.debug_struct("FenceCreateInfo")
18716 .field("s_type", &self.s_type)
18717 .field("p_next", &self.p_next)
18718 .field("flags", &self.flags)
18719 .finish()
18720 }
18721}
18722impl FenceCreateInfo {
18723 #[inline]
18724 pub fn into_builder<'a>(self) -> FenceCreateInfoBuilder<'a> {
18725 FenceCreateInfoBuilder(self, std::marker::PhantomData)
18726 }
18727}
18728#[derive(Copy, Clone)]
18729#[repr(transparent)]
18731pub struct FenceCreateInfoBuilder<'a>(FenceCreateInfo, std::marker::PhantomData<&'a ()>);
18732impl<'a> FenceCreateInfoBuilder<'a> {
18733 #[inline]
18734 pub fn new() -> FenceCreateInfoBuilder<'a> {
18735 FenceCreateInfoBuilder(Default::default(), std::marker::PhantomData)
18736 }
18737 #[inline]
18738 #[must_use]
18739 pub fn flags(mut self, flags: crate::vk1_0::FenceCreateFlags) -> Self {
18740 self.0.flags = flags as _;
18741 self
18742 }
18743 #[inline]
18744 pub fn build_dangling(self) -> FenceCreateInfo {
18747 self.0
18748 }
18749}
18750impl<'a> std::default::Default for FenceCreateInfoBuilder<'a> {
18751 fn default() -> FenceCreateInfoBuilder<'a> {
18752 Self::new()
18753 }
18754}
18755impl<'a> std::fmt::Debug for FenceCreateInfoBuilder<'a> {
18756 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18757 std::fmt::Debug::fmt(&self.0, f)
18758 }
18759}
18760impl<'a> std::ops::Deref for FenceCreateInfoBuilder<'a> {
18761 type Target = FenceCreateInfo;
18762 fn deref(&self) -> &Self::Target {
18763 &self.0
18764 }
18765}
18766impl<'a> std::ops::DerefMut for FenceCreateInfoBuilder<'a> {
18767 fn deref_mut(&mut self) -> &mut Self::Target {
18768 &mut self.0
18769 }
18770}
18771#[doc(alias = "VkPhysicalDeviceFeatures")]
18773#[derive(Copy, Clone, Hash, PartialEq, Eq)]
18774#[repr(C)]
18775pub struct PhysicalDeviceFeatures {
18776 pub robust_buffer_access: crate::vk1_0::Bool32,
18777 pub full_draw_index_uint32: crate::vk1_0::Bool32,
18778 pub image_cube_array: crate::vk1_0::Bool32,
18779 pub independent_blend: crate::vk1_0::Bool32,
18780 pub geometry_shader: crate::vk1_0::Bool32,
18781 pub tessellation_shader: crate::vk1_0::Bool32,
18782 pub sample_rate_shading: crate::vk1_0::Bool32,
18783 pub dual_src_blend: crate::vk1_0::Bool32,
18784 pub logic_op: crate::vk1_0::Bool32,
18785 pub multi_draw_indirect: crate::vk1_0::Bool32,
18786 pub draw_indirect_first_instance: crate::vk1_0::Bool32,
18787 pub depth_clamp: crate::vk1_0::Bool32,
18788 pub depth_bias_clamp: crate::vk1_0::Bool32,
18789 pub fill_mode_non_solid: crate::vk1_0::Bool32,
18790 pub depth_bounds: crate::vk1_0::Bool32,
18791 pub wide_lines: crate::vk1_0::Bool32,
18792 pub large_points: crate::vk1_0::Bool32,
18793 pub alpha_to_one: crate::vk1_0::Bool32,
18794 pub multi_viewport: crate::vk1_0::Bool32,
18795 pub sampler_anisotropy: crate::vk1_0::Bool32,
18796 pub texture_compression_etc2: crate::vk1_0::Bool32,
18797 pub texture_compression_astc_ldr: crate::vk1_0::Bool32,
18798 pub texture_compression_bc: crate::vk1_0::Bool32,
18799 pub occlusion_query_precise: crate::vk1_0::Bool32,
18800 pub pipeline_statistics_query: crate::vk1_0::Bool32,
18801 pub vertex_pipeline_stores_and_atomics: crate::vk1_0::Bool32,
18802 pub fragment_stores_and_atomics: crate::vk1_0::Bool32,
18803 pub shader_tessellation_and_geometry_point_size: crate::vk1_0::Bool32,
18804 pub shader_image_gather_extended: crate::vk1_0::Bool32,
18805 pub shader_storage_image_extended_formats: crate::vk1_0::Bool32,
18806 pub shader_storage_image_multisample: crate::vk1_0::Bool32,
18807 pub shader_storage_image_read_without_format: crate::vk1_0::Bool32,
18808 pub shader_storage_image_write_without_format: crate::vk1_0::Bool32,
18809 pub shader_uniform_buffer_array_dynamic_indexing: crate::vk1_0::Bool32,
18810 pub shader_sampled_image_array_dynamic_indexing: crate::vk1_0::Bool32,
18811 pub shader_storage_buffer_array_dynamic_indexing: crate::vk1_0::Bool32,
18812 pub shader_storage_image_array_dynamic_indexing: crate::vk1_0::Bool32,
18813 pub shader_clip_distance: crate::vk1_0::Bool32,
18814 pub shader_cull_distance: crate::vk1_0::Bool32,
18815 pub shader_float64: crate::vk1_0::Bool32,
18816 pub shader_int64: crate::vk1_0::Bool32,
18817 pub shader_int16: crate::vk1_0::Bool32,
18818 pub shader_resource_residency: crate::vk1_0::Bool32,
18819 pub shader_resource_min_lod: crate::vk1_0::Bool32,
18820 pub sparse_binding: crate::vk1_0::Bool32,
18821 pub sparse_residency_buffer: crate::vk1_0::Bool32,
18822 pub sparse_residency_image2_d: crate::vk1_0::Bool32,
18823 pub sparse_residency_image3_d: crate::vk1_0::Bool32,
18824 pub sparse_residency2_samples: crate::vk1_0::Bool32,
18825 pub sparse_residency4_samples: crate::vk1_0::Bool32,
18826 pub sparse_residency8_samples: crate::vk1_0::Bool32,
18827 pub sparse_residency16_samples: crate::vk1_0::Bool32,
18828 pub sparse_residency_aliased: crate::vk1_0::Bool32,
18829 pub variable_multisample_rate: crate::vk1_0::Bool32,
18830 pub inherited_queries: crate::vk1_0::Bool32,
18831}
18832impl Default for PhysicalDeviceFeatures {
18833 fn default() -> Self {
18834 Self {
18835 robust_buffer_access: Default::default(),
18836 full_draw_index_uint32: Default::default(),
18837 image_cube_array: Default::default(),
18838 independent_blend: Default::default(),
18839 geometry_shader: Default::default(),
18840 tessellation_shader: Default::default(),
18841 sample_rate_shading: Default::default(),
18842 dual_src_blend: Default::default(),
18843 logic_op: Default::default(),
18844 multi_draw_indirect: Default::default(),
18845 draw_indirect_first_instance: Default::default(),
18846 depth_clamp: Default::default(),
18847 depth_bias_clamp: Default::default(),
18848 fill_mode_non_solid: Default::default(),
18849 depth_bounds: Default::default(),
18850 wide_lines: Default::default(),
18851 large_points: Default::default(),
18852 alpha_to_one: Default::default(),
18853 multi_viewport: Default::default(),
18854 sampler_anisotropy: Default::default(),
18855 texture_compression_etc2: Default::default(),
18856 texture_compression_astc_ldr: Default::default(),
18857 texture_compression_bc: Default::default(),
18858 occlusion_query_precise: Default::default(),
18859 pipeline_statistics_query: Default::default(),
18860 vertex_pipeline_stores_and_atomics: Default::default(),
18861 fragment_stores_and_atomics: Default::default(),
18862 shader_tessellation_and_geometry_point_size: Default::default(),
18863 shader_image_gather_extended: Default::default(),
18864 shader_storage_image_extended_formats: Default::default(),
18865 shader_storage_image_multisample: Default::default(),
18866 shader_storage_image_read_without_format: Default::default(),
18867 shader_storage_image_write_without_format: Default::default(),
18868 shader_uniform_buffer_array_dynamic_indexing: Default::default(),
18869 shader_sampled_image_array_dynamic_indexing: Default::default(),
18870 shader_storage_buffer_array_dynamic_indexing: Default::default(),
18871 shader_storage_image_array_dynamic_indexing: Default::default(),
18872 shader_clip_distance: Default::default(),
18873 shader_cull_distance: Default::default(),
18874 shader_float64: Default::default(),
18875 shader_int64: Default::default(),
18876 shader_int16: Default::default(),
18877 shader_resource_residency: Default::default(),
18878 shader_resource_min_lod: Default::default(),
18879 sparse_binding: Default::default(),
18880 sparse_residency_buffer: Default::default(),
18881 sparse_residency_image2_d: Default::default(),
18882 sparse_residency_image3_d: Default::default(),
18883 sparse_residency2_samples: Default::default(),
18884 sparse_residency4_samples: Default::default(),
18885 sparse_residency8_samples: Default::default(),
18886 sparse_residency16_samples: Default::default(),
18887 sparse_residency_aliased: Default::default(),
18888 variable_multisample_rate: Default::default(),
18889 inherited_queries: Default::default(),
18890 }
18891 }
18892}
18893impl std::fmt::Debug for PhysicalDeviceFeatures {
18894 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
18895 f.debug_struct("PhysicalDeviceFeatures")
18896 .field("robust_buffer_access", &(self.robust_buffer_access != 0))
18897 .field("full_draw_index_uint32", &(self.full_draw_index_uint32 != 0))
18898 .field("image_cube_array", &(self.image_cube_array != 0))
18899 .field("independent_blend", &(self.independent_blend != 0))
18900 .field("geometry_shader", &(self.geometry_shader != 0))
18901 .field("tessellation_shader", &(self.tessellation_shader != 0))
18902 .field("sample_rate_shading", &(self.sample_rate_shading != 0))
18903 .field("dual_src_blend", &(self.dual_src_blend != 0))
18904 .field("logic_op", &(self.logic_op != 0))
18905 .field("multi_draw_indirect", &(self.multi_draw_indirect != 0))
18906 .field(
18907 "draw_indirect_first_instance",
18908 &(self.draw_indirect_first_instance != 0),
18909 )
18910 .field("depth_clamp", &(self.depth_clamp != 0))
18911 .field("depth_bias_clamp", &(self.depth_bias_clamp != 0))
18912 .field("fill_mode_non_solid", &(self.fill_mode_non_solid != 0))
18913 .field("depth_bounds", &(self.depth_bounds != 0))
18914 .field("wide_lines", &(self.wide_lines != 0))
18915 .field("large_points", &(self.large_points != 0))
18916 .field("alpha_to_one", &(self.alpha_to_one != 0))
18917 .field("multi_viewport", &(self.multi_viewport != 0))
18918 .field("sampler_anisotropy", &(self.sampler_anisotropy != 0))
18919 .field("texture_compression_etc2", &(self.texture_compression_etc2 != 0))
18920 .field(
18921 "texture_compression_astc_ldr",
18922 &(self.texture_compression_astc_ldr != 0),
18923 )
18924 .field("texture_compression_bc", &(self.texture_compression_bc != 0))
18925 .field("occlusion_query_precise", &(self.occlusion_query_precise != 0))
18926 .field("pipeline_statistics_query", &(self.pipeline_statistics_query != 0))
18927 .field(
18928 "vertex_pipeline_stores_and_atomics",
18929 &(self.vertex_pipeline_stores_and_atomics != 0),
18930 )
18931 .field(
18932 "fragment_stores_and_atomics",
18933 &(self.fragment_stores_and_atomics != 0),
18934 )
18935 .field(
18936 "shader_tessellation_and_geometry_point_size",
18937 &(self.shader_tessellation_and_geometry_point_size != 0),
18938 )
18939 .field(
18940 "shader_image_gather_extended",
18941 &(self.shader_image_gather_extended != 0),
18942 )
18943 .field(
18944 "shader_storage_image_extended_formats",
18945 &(self.shader_storage_image_extended_formats != 0),
18946 )
18947 .field(
18948 "shader_storage_image_multisample",
18949 &(self.shader_storage_image_multisample != 0),
18950 )
18951 .field(
18952 "shader_storage_image_read_without_format",
18953 &(self.shader_storage_image_read_without_format != 0),
18954 )
18955 .field(
18956 "shader_storage_image_write_without_format",
18957 &(self.shader_storage_image_write_without_format != 0),
18958 )
18959 .field(
18960 "shader_uniform_buffer_array_dynamic_indexing",
18961 &(self.shader_uniform_buffer_array_dynamic_indexing != 0),
18962 )
18963 .field(
18964 "shader_sampled_image_array_dynamic_indexing",
18965 &(self.shader_sampled_image_array_dynamic_indexing != 0),
18966 )
18967 .field(
18968 "shader_storage_buffer_array_dynamic_indexing",
18969 &(self.shader_storage_buffer_array_dynamic_indexing != 0),
18970 )
18971 .field(
18972 "shader_storage_image_array_dynamic_indexing",
18973 &(self.shader_storage_image_array_dynamic_indexing != 0),
18974 )
18975 .field("shader_clip_distance", &(self.shader_clip_distance != 0))
18976 .field("shader_cull_distance", &(self.shader_cull_distance != 0))
18977 .field("shader_float64", &(self.shader_float64 != 0))
18978 .field("shader_int64", &(self.shader_int64 != 0))
18979 .field("shader_int16", &(self.shader_int16 != 0))
18980 .field("shader_resource_residency", &(self.shader_resource_residency != 0))
18981 .field("shader_resource_min_lod", &(self.shader_resource_min_lod != 0))
18982 .field("sparse_binding", &(self.sparse_binding != 0))
18983 .field("sparse_residency_buffer", &(self.sparse_residency_buffer != 0))
18984 .field("sparse_residency_image2_d", &(self.sparse_residency_image2_d != 0))
18985 .field("sparse_residency_image3_d", &(self.sparse_residency_image3_d != 0))
18986 .field("sparse_residency2_samples", &(self.sparse_residency2_samples != 0))
18987 .field("sparse_residency4_samples", &(self.sparse_residency4_samples != 0))
18988 .field("sparse_residency8_samples", &(self.sparse_residency8_samples != 0))
18989 .field("sparse_residency16_samples", &(self.sparse_residency16_samples != 0))
18990 .field("sparse_residency_aliased", &(self.sparse_residency_aliased != 0))
18991 .field("variable_multisample_rate", &(self.variable_multisample_rate != 0))
18992 .field("inherited_queries", &(self.inherited_queries != 0))
18993 .finish()
18994 }
18995}
18996impl PhysicalDeviceFeatures {
18997 #[inline]
18998 pub fn into_builder<'a>(self) -> PhysicalDeviceFeaturesBuilder<'a> {
18999 PhysicalDeviceFeaturesBuilder(self, std::marker::PhantomData)
19000 }
19001}
19002#[derive(Copy, Clone)]
19003#[repr(transparent)]
19005pub struct PhysicalDeviceFeaturesBuilder<'a>(
19006 PhysicalDeviceFeatures,
19007 std::marker::PhantomData<&'a ()>,
19008);
19009impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
19010 #[inline]
19011 pub fn new() -> PhysicalDeviceFeaturesBuilder<'a> {
19012 PhysicalDeviceFeaturesBuilder(Default::default(), std::marker::PhantomData)
19013 }
19014 #[inline]
19015 #[must_use]
19016 pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self {
19017 self.0.robust_buffer_access = robust_buffer_access as _;
19018 self
19019 }
19020 #[inline]
19021 #[must_use]
19022 pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self {
19023 self.0.full_draw_index_uint32 = full_draw_index_uint32 as _;
19024 self
19025 }
19026 #[inline]
19027 #[must_use]
19028 pub fn image_cube_array(mut self, image_cube_array: bool) -> Self {
19029 self.0.image_cube_array = image_cube_array as _;
19030 self
19031 }
19032 #[inline]
19033 #[must_use]
19034 pub fn independent_blend(mut self, independent_blend: bool) -> Self {
19035 self.0.independent_blend = independent_blend as _;
19036 self
19037 }
19038 #[inline]
19039 #[must_use]
19040 pub fn geometry_shader(mut self, geometry_shader: bool) -> Self {
19041 self.0.geometry_shader = geometry_shader as _;
19042 self
19043 }
19044 #[inline]
19045 #[must_use]
19046 pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self {
19047 self.0.tessellation_shader = tessellation_shader as _;
19048 self
19049 }
19050 #[inline]
19051 #[must_use]
19052 pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self {
19053 self.0.sample_rate_shading = sample_rate_shading as _;
19054 self
19055 }
19056 #[inline]
19057 #[must_use]
19058 pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self {
19059 self.0.dual_src_blend = dual_src_blend as _;
19060 self
19061 }
19062 #[inline]
19063 #[must_use]
19064 pub fn logic_op(mut self, logic_op: bool) -> Self {
19065 self.0.logic_op = logic_op as _;
19066 self
19067 }
19068 #[inline]
19069 #[must_use]
19070 pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self {
19071 self.0.multi_draw_indirect = multi_draw_indirect as _;
19072 self
19073 }
19074 #[inline]
19075 #[must_use]
19076 pub fn draw_indirect_first_instance(
19077 mut self,
19078 draw_indirect_first_instance: bool,
19079 ) -> Self {
19080 self.0.draw_indirect_first_instance = draw_indirect_first_instance as _;
19081 self
19082 }
19083 #[inline]
19084 #[must_use]
19085 pub fn depth_clamp(mut self, depth_clamp: bool) -> Self {
19086 self.0.depth_clamp = depth_clamp as _;
19087 self
19088 }
19089 #[inline]
19090 #[must_use]
19091 pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self {
19092 self.0.depth_bias_clamp = depth_bias_clamp as _;
19093 self
19094 }
19095 #[inline]
19096 #[must_use]
19097 pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self {
19098 self.0.fill_mode_non_solid = fill_mode_non_solid as _;
19099 self
19100 }
19101 #[inline]
19102 #[must_use]
19103 pub fn depth_bounds(mut self, depth_bounds: bool) -> Self {
19104 self.0.depth_bounds = depth_bounds as _;
19105 self
19106 }
19107 #[inline]
19108 #[must_use]
19109 pub fn wide_lines(mut self, wide_lines: bool) -> Self {
19110 self.0.wide_lines = wide_lines as _;
19111 self
19112 }
19113 #[inline]
19114 #[must_use]
19115 pub fn large_points(mut self, large_points: bool) -> Self {
19116 self.0.large_points = large_points as _;
19117 self
19118 }
19119 #[inline]
19120 #[must_use]
19121 pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self {
19122 self.0.alpha_to_one = alpha_to_one as _;
19123 self
19124 }
19125 #[inline]
19126 #[must_use]
19127 pub fn multi_viewport(mut self, multi_viewport: bool) -> Self {
19128 self.0.multi_viewport = multi_viewport as _;
19129 self
19130 }
19131 #[inline]
19132 #[must_use]
19133 pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self {
19134 self.0.sampler_anisotropy = sampler_anisotropy as _;
19135 self
19136 }
19137 #[inline]
19138 #[must_use]
19139 pub fn texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self {
19140 self.0.texture_compression_etc2 = texture_compression_etc2 as _;
19141 self
19142 }
19143 #[inline]
19144 #[must_use]
19145 pub fn texture_compression_astc_ldr(
19146 mut self,
19147 texture_compression_astc_ldr: bool,
19148 ) -> Self {
19149 self.0.texture_compression_astc_ldr = texture_compression_astc_ldr as _;
19150 self
19151 }
19152 #[inline]
19153 #[must_use]
19154 pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self {
19155 self.0.texture_compression_bc = texture_compression_bc as _;
19156 self
19157 }
19158 #[inline]
19159 #[must_use]
19160 pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self {
19161 self.0.occlusion_query_precise = occlusion_query_precise as _;
19162 self
19163 }
19164 #[inline]
19165 #[must_use]
19166 pub fn pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self {
19167 self.0.pipeline_statistics_query = pipeline_statistics_query as _;
19168 self
19169 }
19170 #[inline]
19171 #[must_use]
19172 pub fn vertex_pipeline_stores_and_atomics(
19173 mut self,
19174 vertex_pipeline_stores_and_atomics: bool,
19175 ) -> Self {
19176 self
19177 .0
19178 .vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics
19179 as _;
19180 self
19181 }
19182 #[inline]
19183 #[must_use]
19184 pub fn fragment_stores_and_atomics(
19185 mut self,
19186 fragment_stores_and_atomics: bool,
19187 ) -> Self {
19188 self.0.fragment_stores_and_atomics = fragment_stores_and_atomics as _;
19189 self
19190 }
19191 #[inline]
19192 #[must_use]
19193 pub fn shader_tessellation_and_geometry_point_size(
19194 mut self,
19195 shader_tessellation_and_geometry_point_size: bool,
19196 ) -> Self {
19197 self
19198 .0
19199 .shader_tessellation_and_geometry_point_size = shader_tessellation_and_geometry_point_size
19200 as _;
19201 self
19202 }
19203 #[inline]
19204 #[must_use]
19205 pub fn shader_image_gather_extended(
19206 mut self,
19207 shader_image_gather_extended: bool,
19208 ) -> Self {
19209 self.0.shader_image_gather_extended = shader_image_gather_extended as _;
19210 self
19211 }
19212 #[inline]
19213 #[must_use]
19214 pub fn shader_storage_image_extended_formats(
19215 mut self,
19216 shader_storage_image_extended_formats: bool,
19217 ) -> Self {
19218 self
19219 .0
19220 .shader_storage_image_extended_formats = shader_storage_image_extended_formats
19221 as _;
19222 self
19223 }
19224 #[inline]
19225 #[must_use]
19226 pub fn shader_storage_image_multisample(
19227 mut self,
19228 shader_storage_image_multisample: bool,
19229 ) -> Self {
19230 self.0.shader_storage_image_multisample = shader_storage_image_multisample as _;
19231 self
19232 }
19233 #[inline]
19234 #[must_use]
19235 pub fn shader_storage_image_read_without_format(
19236 mut self,
19237 shader_storage_image_read_without_format: bool,
19238 ) -> Self {
19239 self
19240 .0
19241 .shader_storage_image_read_without_format = shader_storage_image_read_without_format
19242 as _;
19243 self
19244 }
19245 #[inline]
19246 #[must_use]
19247 pub fn shader_storage_image_write_without_format(
19248 mut self,
19249 shader_storage_image_write_without_format: bool,
19250 ) -> Self {
19251 self
19252 .0
19253 .shader_storage_image_write_without_format = shader_storage_image_write_without_format
19254 as _;
19255 self
19256 }
19257 #[inline]
19258 #[must_use]
19259 pub fn shader_uniform_buffer_array_dynamic_indexing(
19260 mut self,
19261 shader_uniform_buffer_array_dynamic_indexing: bool,
19262 ) -> Self {
19263 self
19264 .0
19265 .shader_uniform_buffer_array_dynamic_indexing = shader_uniform_buffer_array_dynamic_indexing
19266 as _;
19267 self
19268 }
19269 #[inline]
19270 #[must_use]
19271 pub fn shader_sampled_image_array_dynamic_indexing(
19272 mut self,
19273 shader_sampled_image_array_dynamic_indexing: bool,
19274 ) -> Self {
19275 self
19276 .0
19277 .shader_sampled_image_array_dynamic_indexing = shader_sampled_image_array_dynamic_indexing
19278 as _;
19279 self
19280 }
19281 #[inline]
19282 #[must_use]
19283 pub fn shader_storage_buffer_array_dynamic_indexing(
19284 mut self,
19285 shader_storage_buffer_array_dynamic_indexing: bool,
19286 ) -> Self {
19287 self
19288 .0
19289 .shader_storage_buffer_array_dynamic_indexing = shader_storage_buffer_array_dynamic_indexing
19290 as _;
19291 self
19292 }
19293 #[inline]
19294 #[must_use]
19295 pub fn shader_storage_image_array_dynamic_indexing(
19296 mut self,
19297 shader_storage_image_array_dynamic_indexing: bool,
19298 ) -> Self {
19299 self
19300 .0
19301 .shader_storage_image_array_dynamic_indexing = shader_storage_image_array_dynamic_indexing
19302 as _;
19303 self
19304 }
19305 #[inline]
19306 #[must_use]
19307 pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self {
19308 self.0.shader_clip_distance = shader_clip_distance as _;
19309 self
19310 }
19311 #[inline]
19312 #[must_use]
19313 pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self {
19314 self.0.shader_cull_distance = shader_cull_distance as _;
19315 self
19316 }
19317 #[inline]
19318 #[must_use]
19319 pub fn shader_float64(mut self, shader_float64: bool) -> Self {
19320 self.0.shader_float64 = shader_float64 as _;
19321 self
19322 }
19323 #[inline]
19324 #[must_use]
19325 pub fn shader_int64(mut self, shader_int64: bool) -> Self {
19326 self.0.shader_int64 = shader_int64 as _;
19327 self
19328 }
19329 #[inline]
19330 #[must_use]
19331 pub fn shader_int16(mut self, shader_int16: bool) -> Self {
19332 self.0.shader_int16 = shader_int16 as _;
19333 self
19334 }
19335 #[inline]
19336 #[must_use]
19337 pub fn shader_resource_residency(mut self, shader_resource_residency: bool) -> Self {
19338 self.0.shader_resource_residency = shader_resource_residency as _;
19339 self
19340 }
19341 #[inline]
19342 #[must_use]
19343 pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self {
19344 self.0.shader_resource_min_lod = shader_resource_min_lod as _;
19345 self
19346 }
19347 #[inline]
19348 #[must_use]
19349 pub fn sparse_binding(mut self, sparse_binding: bool) -> Self {
19350 self.0.sparse_binding = sparse_binding as _;
19351 self
19352 }
19353 #[inline]
19354 #[must_use]
19355 pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self {
19356 self.0.sparse_residency_buffer = sparse_residency_buffer as _;
19357 self
19358 }
19359 #[inline]
19360 #[must_use]
19361 pub fn sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self {
19362 self.0.sparse_residency_image2_d = sparse_residency_image2_d as _;
19363 self
19364 }
19365 #[inline]
19366 #[must_use]
19367 pub fn sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self {
19368 self.0.sparse_residency_image3_d = sparse_residency_image3_d as _;
19369 self
19370 }
19371 #[inline]
19372 #[must_use]
19373 pub fn sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self {
19374 self.0.sparse_residency2_samples = sparse_residency2_samples as _;
19375 self
19376 }
19377 #[inline]
19378 #[must_use]
19379 pub fn sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self {
19380 self.0.sparse_residency4_samples = sparse_residency4_samples as _;
19381 self
19382 }
19383 #[inline]
19384 #[must_use]
19385 pub fn sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self {
19386 self.0.sparse_residency8_samples = sparse_residency8_samples as _;
19387 self
19388 }
19389 #[inline]
19390 #[must_use]
19391 pub fn sparse_residency16_samples(
19392 mut self,
19393 sparse_residency16_samples: bool,
19394 ) -> Self {
19395 self.0.sparse_residency16_samples = sparse_residency16_samples as _;
19396 self
19397 }
19398 #[inline]
19399 #[must_use]
19400 pub fn sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self {
19401 self.0.sparse_residency_aliased = sparse_residency_aliased as _;
19402 self
19403 }
19404 #[inline]
19405 #[must_use]
19406 pub fn variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self {
19407 self.0.variable_multisample_rate = variable_multisample_rate as _;
19408 self
19409 }
19410 #[inline]
19411 #[must_use]
19412 pub fn inherited_queries(mut self, inherited_queries: bool) -> Self {
19413 self.0.inherited_queries = inherited_queries as _;
19414 self
19415 }
19416 #[inline]
19417 pub fn build(self) -> PhysicalDeviceFeatures {
19418 self.0
19419 }
19420}
19421impl<'a> std::default::Default for PhysicalDeviceFeaturesBuilder<'a> {
19422 fn default() -> PhysicalDeviceFeaturesBuilder<'a> {
19423 Self::new()
19424 }
19425}
19426impl<'a> std::fmt::Debug for PhysicalDeviceFeaturesBuilder<'a> {
19427 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
19428 std::fmt::Debug::fmt(&self.0, f)
19429 }
19430}
19431impl<'a> std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> {
19432 type Target = PhysicalDeviceFeatures;
19433 fn deref(&self) -> &Self::Target {
19434 &self.0
19435 }
19436}
19437impl<'a> std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> {
19438 fn deref_mut(&mut self) -> &mut Self::Target {
19439 &mut self.0
19440 }
19441}
19442#[doc(alias = "VkPhysicalDeviceSparseProperties")]
19444#[derive(Copy, Clone, Hash, PartialEq, Eq)]
19445#[repr(C)]
19446pub struct PhysicalDeviceSparseProperties {
19447 pub residency_standard2_d_block_shape: crate::vk1_0::Bool32,
19448 pub residency_standard2_d_multisample_block_shape: crate::vk1_0::Bool32,
19449 pub residency_standard3_d_block_shape: crate::vk1_0::Bool32,
19450 pub residency_aligned_mip_size: crate::vk1_0::Bool32,
19451 pub residency_non_resident_strict: crate::vk1_0::Bool32,
19452}
19453impl Default for PhysicalDeviceSparseProperties {
19454 fn default() -> Self {
19455 Self {
19456 residency_standard2_d_block_shape: Default::default(),
19457 residency_standard2_d_multisample_block_shape: Default::default(),
19458 residency_standard3_d_block_shape: Default::default(),
19459 residency_aligned_mip_size: Default::default(),
19460 residency_non_resident_strict: Default::default(),
19461 }
19462 }
19463}
19464impl std::fmt::Debug for PhysicalDeviceSparseProperties {
19465 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
19466 f.debug_struct("PhysicalDeviceSparseProperties")
19467 .field(
19468 "residency_standard2_d_block_shape",
19469 &(self.residency_standard2_d_block_shape != 0),
19470 )
19471 .field(
19472 "residency_standard2_d_multisample_block_shape",
19473 &(self.residency_standard2_d_multisample_block_shape != 0),
19474 )
19475 .field(
19476 "residency_standard3_d_block_shape",
19477 &(self.residency_standard3_d_block_shape != 0),
19478 )
19479 .field("residency_aligned_mip_size", &(self.residency_aligned_mip_size != 0))
19480 .field(
19481 "residency_non_resident_strict",
19482 &(self.residency_non_resident_strict != 0),
19483 )
19484 .finish()
19485 }
19486}
19487impl PhysicalDeviceSparseProperties {
19488 #[inline]
19489 pub fn into_builder<'a>(self) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
19490 PhysicalDeviceSparsePropertiesBuilder(self, std::marker::PhantomData)
19491 }
19492}
19493#[derive(Copy, Clone)]
19494#[repr(transparent)]
19496pub struct PhysicalDeviceSparsePropertiesBuilder<'a>(
19497 PhysicalDeviceSparseProperties,
19498 std::marker::PhantomData<&'a ()>,
19499);
19500impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
19501 #[inline]
19502 pub fn new() -> PhysicalDeviceSparsePropertiesBuilder<'a> {
19503 PhysicalDeviceSparsePropertiesBuilder(
19504 Default::default(),
19505 std::marker::PhantomData,
19506 )
19507 }
19508 #[inline]
19509 #[must_use]
19510 pub fn residency_standard2_d_block_shape(
19511 mut self,
19512 residency_standard2_d_block_shape: bool,
19513 ) -> Self {
19514 self
19515 .0
19516 .residency_standard2_d_block_shape = residency_standard2_d_block_shape as _;
19517 self
19518 }
19519 #[inline]
19520 #[must_use]
19521 pub fn residency_standard2_d_multisample_block_shape(
19522 mut self,
19523 residency_standard2_d_multisample_block_shape: bool,
19524 ) -> Self {
19525 self
19526 .0
19527 .residency_standard2_d_multisample_block_shape = residency_standard2_d_multisample_block_shape
19528 as _;
19529 self
19530 }
19531 #[inline]
19532 #[must_use]
19533 pub fn residency_standard3_d_block_shape(
19534 mut self,
19535 residency_standard3_d_block_shape: bool,
19536 ) -> Self {
19537 self
19538 .0
19539 .residency_standard3_d_block_shape = residency_standard3_d_block_shape as _;
19540 self
19541 }
19542 #[inline]
19543 #[must_use]
19544 pub fn residency_aligned_mip_size(
19545 mut self,
19546 residency_aligned_mip_size: bool,
19547 ) -> Self {
19548 self.0.residency_aligned_mip_size = residency_aligned_mip_size as _;
19549 self
19550 }
19551 #[inline]
19552 #[must_use]
19553 pub fn residency_non_resident_strict(
19554 mut self,
19555 residency_non_resident_strict: bool,
19556 ) -> Self {
19557 self.0.residency_non_resident_strict = residency_non_resident_strict as _;
19558 self
19559 }
19560 #[inline]
19561 pub fn build(self) -> PhysicalDeviceSparseProperties {
19562 self.0
19563 }
19564}
19565impl<'a> std::default::Default for PhysicalDeviceSparsePropertiesBuilder<'a> {
19566 fn default() -> PhysicalDeviceSparsePropertiesBuilder<'a> {
19567 Self::new()
19568 }
19569}
19570impl<'a> std::fmt::Debug for PhysicalDeviceSparsePropertiesBuilder<'a> {
19571 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
19572 std::fmt::Debug::fmt(&self.0, f)
19573 }
19574}
19575impl<'a> std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> {
19576 type Target = PhysicalDeviceSparseProperties;
19577 fn deref(&self) -> &Self::Target {
19578 &self.0
19579 }
19580}
19581impl<'a> std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> {
19582 fn deref_mut(&mut self) -> &mut Self::Target {
19583 &mut self.0
19584 }
19585}
19586#[doc(alias = "VkPhysicalDeviceLimits")]
19588#[derive(Copy, Clone)]
19589#[repr(C)]
19590pub struct PhysicalDeviceLimits {
19591 pub max_image_dimension1_d: u32,
19592 pub max_image_dimension2_d: u32,
19593 pub max_image_dimension3_d: u32,
19594 pub max_image_dimension_cube: u32,
19595 pub max_image_array_layers: u32,
19596 pub max_texel_buffer_elements: u32,
19597 pub max_uniform_buffer_range: u32,
19598 pub max_storage_buffer_range: u32,
19599 pub max_push_constants_size: u32,
19600 pub max_memory_allocation_count: u32,
19601 pub max_sampler_allocation_count: u32,
19602 pub buffer_image_granularity: crate::vk1_0::DeviceSize,
19603 pub sparse_address_space_size: crate::vk1_0::DeviceSize,
19604 pub max_bound_descriptor_sets: u32,
19605 pub max_per_stage_descriptor_samplers: u32,
19606 pub max_per_stage_descriptor_uniform_buffers: u32,
19607 pub max_per_stage_descriptor_storage_buffers: u32,
19608 pub max_per_stage_descriptor_sampled_images: u32,
19609 pub max_per_stage_descriptor_storage_images: u32,
19610 pub max_per_stage_descriptor_input_attachments: u32,
19611 pub max_per_stage_resources: u32,
19612 pub max_descriptor_set_samplers: u32,
19613 pub max_descriptor_set_uniform_buffers: u32,
19614 pub max_descriptor_set_uniform_buffers_dynamic: u32,
19615 pub max_descriptor_set_storage_buffers: u32,
19616 pub max_descriptor_set_storage_buffers_dynamic: u32,
19617 pub max_descriptor_set_sampled_images: u32,
19618 pub max_descriptor_set_storage_images: u32,
19619 pub max_descriptor_set_input_attachments: u32,
19620 pub max_vertex_input_attributes: u32,
19621 pub max_vertex_input_bindings: u32,
19622 pub max_vertex_input_attribute_offset: u32,
19623 pub max_vertex_input_binding_stride: u32,
19624 pub max_vertex_output_components: u32,
19625 pub max_tessellation_generation_level: u32,
19626 pub max_tessellation_patch_size: u32,
19627 pub max_tessellation_control_per_vertex_input_components: u32,
19628 pub max_tessellation_control_per_vertex_output_components: u32,
19629 pub max_tessellation_control_per_patch_output_components: u32,
19630 pub max_tessellation_control_total_output_components: u32,
19631 pub max_tessellation_evaluation_input_components: u32,
19632 pub max_tessellation_evaluation_output_components: u32,
19633 pub max_geometry_shader_invocations: u32,
19634 pub max_geometry_input_components: u32,
19635 pub max_geometry_output_components: u32,
19636 pub max_geometry_output_vertices: u32,
19637 pub max_geometry_total_output_components: u32,
19638 pub max_fragment_input_components: u32,
19639 pub max_fragment_output_attachments: u32,
19640 pub max_fragment_dual_src_attachments: u32,
19641 pub max_fragment_combined_output_resources: u32,
19642 pub max_compute_shared_memory_size: u32,
19643 pub max_compute_work_group_count: [u32; 3],
19644 pub max_compute_work_group_invocations: u32,
19645 pub max_compute_work_group_size: [u32; 3],
19646 pub sub_pixel_precision_bits: u32,
19647 pub sub_texel_precision_bits: u32,
19648 pub mipmap_precision_bits: u32,
19649 pub max_draw_indexed_index_value: u32,
19650 pub max_draw_indirect_count: u32,
19651 pub max_sampler_lod_bias: std::os::raw::c_float,
19652 pub max_sampler_anisotropy: std::os::raw::c_float,
19653 pub max_viewports: u32,
19654 pub max_viewport_dimensions: [u32; 2],
19655 pub viewport_bounds_range: [std::os::raw::c_float; 2],
19656 pub viewport_sub_pixel_bits: u32,
19657 pub min_memory_map_alignment: usize,
19658 pub min_texel_buffer_offset_alignment: crate::vk1_0::DeviceSize,
19659 pub min_uniform_buffer_offset_alignment: crate::vk1_0::DeviceSize,
19660 pub min_storage_buffer_offset_alignment: crate::vk1_0::DeviceSize,
19661 pub min_texel_offset: i32,
19662 pub max_texel_offset: u32,
19663 pub min_texel_gather_offset: i32,
19664 pub max_texel_gather_offset: u32,
19665 pub min_interpolation_offset: std::os::raw::c_float,
19666 pub max_interpolation_offset: std::os::raw::c_float,
19667 pub sub_pixel_interpolation_offset_bits: u32,
19668 pub max_framebuffer_width: u32,
19669 pub max_framebuffer_height: u32,
19670 pub max_framebuffer_layers: u32,
19671 pub framebuffer_color_sample_counts: crate::vk1_0::SampleCountFlags,
19672 pub framebuffer_depth_sample_counts: crate::vk1_0::SampleCountFlags,
19673 pub framebuffer_stencil_sample_counts: crate::vk1_0::SampleCountFlags,
19674 pub framebuffer_no_attachments_sample_counts: crate::vk1_0::SampleCountFlags,
19675 pub max_color_attachments: u32,
19676 pub sampled_image_color_sample_counts: crate::vk1_0::SampleCountFlags,
19677 pub sampled_image_integer_sample_counts: crate::vk1_0::SampleCountFlags,
19678 pub sampled_image_depth_sample_counts: crate::vk1_0::SampleCountFlags,
19679 pub sampled_image_stencil_sample_counts: crate::vk1_0::SampleCountFlags,
19680 pub storage_image_sample_counts: crate::vk1_0::SampleCountFlags,
19681 pub max_sample_mask_words: u32,
19682 pub timestamp_compute_and_graphics: crate::vk1_0::Bool32,
19683 pub timestamp_period: std::os::raw::c_float,
19684 pub max_clip_distances: u32,
19685 pub max_cull_distances: u32,
19686 pub max_combined_clip_and_cull_distances: u32,
19687 pub discrete_queue_priorities: u32,
19688 pub point_size_range: [std::os::raw::c_float; 2],
19689 pub line_width_range: [std::os::raw::c_float; 2],
19690 pub point_size_granularity: std::os::raw::c_float,
19691 pub line_width_granularity: std::os::raw::c_float,
19692 pub strict_lines: crate::vk1_0::Bool32,
19693 pub standard_sample_locations: crate::vk1_0::Bool32,
19694 pub optimal_buffer_copy_offset_alignment: crate::vk1_0::DeviceSize,
19695 pub optimal_buffer_copy_row_pitch_alignment: crate::vk1_0::DeviceSize,
19696 pub non_coherent_atom_size: crate::vk1_0::DeviceSize,
19697}
19698impl Default for PhysicalDeviceLimits {
19699 fn default() -> Self {
19700 Self {
19701 max_image_dimension1_d: Default::default(),
19702 max_image_dimension2_d: Default::default(),
19703 max_image_dimension3_d: Default::default(),
19704 max_image_dimension_cube: Default::default(),
19705 max_image_array_layers: Default::default(),
19706 max_texel_buffer_elements: Default::default(),
19707 max_uniform_buffer_range: Default::default(),
19708 max_storage_buffer_range: Default::default(),
19709 max_push_constants_size: Default::default(),
19710 max_memory_allocation_count: Default::default(),
19711 max_sampler_allocation_count: Default::default(),
19712 buffer_image_granularity: Default::default(),
19713 sparse_address_space_size: Default::default(),
19714 max_bound_descriptor_sets: Default::default(),
19715 max_per_stage_descriptor_samplers: Default::default(),
19716 max_per_stage_descriptor_uniform_buffers: Default::default(),
19717 max_per_stage_descriptor_storage_buffers: Default::default(),
19718 max_per_stage_descriptor_sampled_images: Default::default(),
19719 max_per_stage_descriptor_storage_images: Default::default(),
19720 max_per_stage_descriptor_input_attachments: Default::default(),
19721 max_per_stage_resources: Default::default(),
19722 max_descriptor_set_samplers: Default::default(),
19723 max_descriptor_set_uniform_buffers: Default::default(),
19724 max_descriptor_set_uniform_buffers_dynamic: Default::default(),
19725 max_descriptor_set_storage_buffers: Default::default(),
19726 max_descriptor_set_storage_buffers_dynamic: Default::default(),
19727 max_descriptor_set_sampled_images: Default::default(),
19728 max_descriptor_set_storage_images: Default::default(),
19729 max_descriptor_set_input_attachments: Default::default(),
19730 max_vertex_input_attributes: Default::default(),
19731 max_vertex_input_bindings: Default::default(),
19732 max_vertex_input_attribute_offset: Default::default(),
19733 max_vertex_input_binding_stride: Default::default(),
19734 max_vertex_output_components: Default::default(),
19735 max_tessellation_generation_level: Default::default(),
19736 max_tessellation_patch_size: Default::default(),
19737 max_tessellation_control_per_vertex_input_components: Default::default(),
19738 max_tessellation_control_per_vertex_output_components: Default::default(),
19739 max_tessellation_control_per_patch_output_components: Default::default(),
19740 max_tessellation_control_total_output_components: Default::default(),
19741 max_tessellation_evaluation_input_components: Default::default(),
19742 max_tessellation_evaluation_output_components: Default::default(),
19743 max_geometry_shader_invocations: Default::default(),
19744 max_geometry_input_components: Default::default(),
19745 max_geometry_output_components: Default::default(),
19746 max_geometry_output_vertices: Default::default(),
19747 max_geometry_total_output_components: Default::default(),
19748 max_fragment_input_components: Default::default(),
19749 max_fragment_output_attachments: Default::default(),
19750 max_fragment_dual_src_attachments: Default::default(),
19751 max_fragment_combined_output_resources: Default::default(),
19752 max_compute_shared_memory_size: Default::default(),
19753 max_compute_work_group_count: unsafe { std::mem::zeroed() },
19754 max_compute_work_group_invocations: Default::default(),
19755 max_compute_work_group_size: unsafe { std::mem::zeroed() },
19756 sub_pixel_precision_bits: Default::default(),
19757 sub_texel_precision_bits: Default::default(),
19758 mipmap_precision_bits: Default::default(),
19759 max_draw_indexed_index_value: Default::default(),
19760 max_draw_indirect_count: Default::default(),
19761 max_sampler_lod_bias: Default::default(),
19762 max_sampler_anisotropy: Default::default(),
19763 max_viewports: Default::default(),
19764 max_viewport_dimensions: unsafe { std::mem::zeroed() },
19765 viewport_bounds_range: unsafe { std::mem::zeroed() },
19766 viewport_sub_pixel_bits: Default::default(),
19767 min_memory_map_alignment: Default::default(),
19768 min_texel_buffer_offset_alignment: Default::default(),
19769 min_uniform_buffer_offset_alignment: Default::default(),
19770 min_storage_buffer_offset_alignment: Default::default(),
19771 min_texel_offset: Default::default(),
19772 max_texel_offset: Default::default(),
19773 min_texel_gather_offset: Default::default(),
19774 max_texel_gather_offset: Default::default(),
19775 min_interpolation_offset: Default::default(),
19776 max_interpolation_offset: Default::default(),
19777 sub_pixel_interpolation_offset_bits: Default::default(),
19778 max_framebuffer_width: Default::default(),
19779 max_framebuffer_height: Default::default(),
19780 max_framebuffer_layers: Default::default(),
19781 framebuffer_color_sample_counts: Default::default(),
19782 framebuffer_depth_sample_counts: Default::default(),
19783 framebuffer_stencil_sample_counts: Default::default(),
19784 framebuffer_no_attachments_sample_counts: Default::default(),
19785 max_color_attachments: Default::default(),
19786 sampled_image_color_sample_counts: Default::default(),
19787 sampled_image_integer_sample_counts: Default::default(),
19788 sampled_image_depth_sample_counts: Default::default(),
19789 sampled_image_stencil_sample_counts: Default::default(),
19790 storage_image_sample_counts: Default::default(),
19791 max_sample_mask_words: Default::default(),
19792 timestamp_compute_and_graphics: Default::default(),
19793 timestamp_period: Default::default(),
19794 max_clip_distances: Default::default(),
19795 max_cull_distances: Default::default(),
19796 max_combined_clip_and_cull_distances: Default::default(),
19797 discrete_queue_priorities: Default::default(),
19798 point_size_range: unsafe { std::mem::zeroed() },
19799 line_width_range: unsafe { std::mem::zeroed() },
19800 point_size_granularity: Default::default(),
19801 line_width_granularity: Default::default(),
19802 strict_lines: Default::default(),
19803 standard_sample_locations: Default::default(),
19804 optimal_buffer_copy_offset_alignment: Default::default(),
19805 optimal_buffer_copy_row_pitch_alignment: Default::default(),
19806 non_coherent_atom_size: Default::default(),
19807 }
19808 }
19809}
19810impl std::fmt::Debug for PhysicalDeviceLimits {
19811 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
19812 f.debug_struct("PhysicalDeviceLimits")
19813 .field("max_image_dimension1_d", &self.max_image_dimension1_d)
19814 .field("max_image_dimension2_d", &self.max_image_dimension2_d)
19815 .field("max_image_dimension3_d", &self.max_image_dimension3_d)
19816 .field("max_image_dimension_cube", &self.max_image_dimension_cube)
19817 .field("max_image_array_layers", &self.max_image_array_layers)
19818 .field("max_texel_buffer_elements", &self.max_texel_buffer_elements)
19819 .field("max_uniform_buffer_range", &self.max_uniform_buffer_range)
19820 .field("max_storage_buffer_range", &self.max_storage_buffer_range)
19821 .field("max_push_constants_size", &self.max_push_constants_size)
19822 .field("max_memory_allocation_count", &self.max_memory_allocation_count)
19823 .field("max_sampler_allocation_count", &self.max_sampler_allocation_count)
19824 .field("buffer_image_granularity", &self.buffer_image_granularity)
19825 .field("sparse_address_space_size", &self.sparse_address_space_size)
19826 .field("max_bound_descriptor_sets", &self.max_bound_descriptor_sets)
19827 .field(
19828 "max_per_stage_descriptor_samplers",
19829 &self.max_per_stage_descriptor_samplers,
19830 )
19831 .field(
19832 "max_per_stage_descriptor_uniform_buffers",
19833 &self.max_per_stage_descriptor_uniform_buffers,
19834 )
19835 .field(
19836 "max_per_stage_descriptor_storage_buffers",
19837 &self.max_per_stage_descriptor_storage_buffers,
19838 )
19839 .field(
19840 "max_per_stage_descriptor_sampled_images",
19841 &self.max_per_stage_descriptor_sampled_images,
19842 )
19843 .field(
19844 "max_per_stage_descriptor_storage_images",
19845 &self.max_per_stage_descriptor_storage_images,
19846 )
19847 .field(
19848 "max_per_stage_descriptor_input_attachments",
19849 &self.max_per_stage_descriptor_input_attachments,
19850 )
19851 .field("max_per_stage_resources", &self.max_per_stage_resources)
19852 .field("max_descriptor_set_samplers", &self.max_descriptor_set_samplers)
19853 .field(
19854 "max_descriptor_set_uniform_buffers",
19855 &self.max_descriptor_set_uniform_buffers,
19856 )
19857 .field(
19858 "max_descriptor_set_uniform_buffers_dynamic",
19859 &self.max_descriptor_set_uniform_buffers_dynamic,
19860 )
19861 .field(
19862 "max_descriptor_set_storage_buffers",
19863 &self.max_descriptor_set_storage_buffers,
19864 )
19865 .field(
19866 "max_descriptor_set_storage_buffers_dynamic",
19867 &self.max_descriptor_set_storage_buffers_dynamic,
19868 )
19869 .field(
19870 "max_descriptor_set_sampled_images",
19871 &self.max_descriptor_set_sampled_images,
19872 )
19873 .field(
19874 "max_descriptor_set_storage_images",
19875 &self.max_descriptor_set_storage_images,
19876 )
19877 .field(
19878 "max_descriptor_set_input_attachments",
19879 &self.max_descriptor_set_input_attachments,
19880 )
19881 .field("max_vertex_input_attributes", &self.max_vertex_input_attributes)
19882 .field("max_vertex_input_bindings", &self.max_vertex_input_bindings)
19883 .field(
19884 "max_vertex_input_attribute_offset",
19885 &self.max_vertex_input_attribute_offset,
19886 )
19887 .field(
19888 "max_vertex_input_binding_stride",
19889 &self.max_vertex_input_binding_stride,
19890 )
19891 .field("max_vertex_output_components", &self.max_vertex_output_components)
19892 .field(
19893 "max_tessellation_generation_level",
19894 &self.max_tessellation_generation_level,
19895 )
19896 .field("max_tessellation_patch_size", &self.max_tessellation_patch_size)
19897 .field(
19898 "max_tessellation_control_per_vertex_input_components",
19899 &self.max_tessellation_control_per_vertex_input_components,
19900 )
19901 .field(
19902 "max_tessellation_control_per_vertex_output_components",
19903 &self.max_tessellation_control_per_vertex_output_components,
19904 )
19905 .field(
19906 "max_tessellation_control_per_patch_output_components",
19907 &self.max_tessellation_control_per_patch_output_components,
19908 )
19909 .field(
19910 "max_tessellation_control_total_output_components",
19911 &self.max_tessellation_control_total_output_components,
19912 )
19913 .field(
19914 "max_tessellation_evaluation_input_components",
19915 &self.max_tessellation_evaluation_input_components,
19916 )
19917 .field(
19918 "max_tessellation_evaluation_output_components",
19919 &self.max_tessellation_evaluation_output_components,
19920 )
19921 .field(
19922 "max_geometry_shader_invocations",
19923 &self.max_geometry_shader_invocations,
19924 )
19925 .field("max_geometry_input_components", &self.max_geometry_input_components)
19926 .field(
19927 "max_geometry_output_components",
19928 &self.max_geometry_output_components,
19929 )
19930 .field("max_geometry_output_vertices", &self.max_geometry_output_vertices)
19931 .field(
19932 "max_geometry_total_output_components",
19933 &self.max_geometry_total_output_components,
19934 )
19935 .field("max_fragment_input_components", &self.max_fragment_input_components)
19936 .field(
19937 "max_fragment_output_attachments",
19938 &self.max_fragment_output_attachments,
19939 )
19940 .field(
19941 "max_fragment_dual_src_attachments",
19942 &self.max_fragment_dual_src_attachments,
19943 )
19944 .field(
19945 "max_fragment_combined_output_resources",
19946 &self.max_fragment_combined_output_resources,
19947 )
19948 .field(
19949 "max_compute_shared_memory_size",
19950 &self.max_compute_shared_memory_size,
19951 )
19952 .field("max_compute_work_group_count", &self.max_compute_work_group_count)
19953 .field(
19954 "max_compute_work_group_invocations",
19955 &self.max_compute_work_group_invocations,
19956 )
19957 .field("max_compute_work_group_size", &self.max_compute_work_group_size)
19958 .field("sub_pixel_precision_bits", &self.sub_pixel_precision_bits)
19959 .field("sub_texel_precision_bits", &self.sub_texel_precision_bits)
19960 .field("mipmap_precision_bits", &self.mipmap_precision_bits)
19961 .field("max_draw_indexed_index_value", &self.max_draw_indexed_index_value)
19962 .field("max_draw_indirect_count", &self.max_draw_indirect_count)
19963 .field("max_sampler_lod_bias", &self.max_sampler_lod_bias)
19964 .field("max_sampler_anisotropy", &self.max_sampler_anisotropy)
19965 .field("max_viewports", &self.max_viewports)
19966 .field("max_viewport_dimensions", &self.max_viewport_dimensions)
19967 .field("viewport_bounds_range", &self.viewport_bounds_range)
19968 .field("viewport_sub_pixel_bits", &self.viewport_sub_pixel_bits)
19969 .field("min_memory_map_alignment", &self.min_memory_map_alignment)
19970 .field(
19971 "min_texel_buffer_offset_alignment",
19972 &self.min_texel_buffer_offset_alignment,
19973 )
19974 .field(
19975 "min_uniform_buffer_offset_alignment",
19976 &self.min_uniform_buffer_offset_alignment,
19977 )
19978 .field(
19979 "min_storage_buffer_offset_alignment",
19980 &self.min_storage_buffer_offset_alignment,
19981 )
19982 .field("min_texel_offset", &self.min_texel_offset)
19983 .field("max_texel_offset", &self.max_texel_offset)
19984 .field("min_texel_gather_offset", &self.min_texel_gather_offset)
19985 .field("max_texel_gather_offset", &self.max_texel_gather_offset)
19986 .field("min_interpolation_offset", &self.min_interpolation_offset)
19987 .field("max_interpolation_offset", &self.max_interpolation_offset)
19988 .field(
19989 "sub_pixel_interpolation_offset_bits",
19990 &self.sub_pixel_interpolation_offset_bits,
19991 )
19992 .field("max_framebuffer_width", &self.max_framebuffer_width)
19993 .field("max_framebuffer_height", &self.max_framebuffer_height)
19994 .field("max_framebuffer_layers", &self.max_framebuffer_layers)
19995 .field(
19996 "framebuffer_color_sample_counts",
19997 &self.framebuffer_color_sample_counts,
19998 )
19999 .field(
20000 "framebuffer_depth_sample_counts",
20001 &self.framebuffer_depth_sample_counts,
20002 )
20003 .field(
20004 "framebuffer_stencil_sample_counts",
20005 &self.framebuffer_stencil_sample_counts,
20006 )
20007 .field(
20008 "framebuffer_no_attachments_sample_counts",
20009 &self.framebuffer_no_attachments_sample_counts,
20010 )
20011 .field("max_color_attachments", &self.max_color_attachments)
20012 .field(
20013 "sampled_image_color_sample_counts",
20014 &self.sampled_image_color_sample_counts,
20015 )
20016 .field(
20017 "sampled_image_integer_sample_counts",
20018 &self.sampled_image_integer_sample_counts,
20019 )
20020 .field(
20021 "sampled_image_depth_sample_counts",
20022 &self.sampled_image_depth_sample_counts,
20023 )
20024 .field(
20025 "sampled_image_stencil_sample_counts",
20026 &self.sampled_image_stencil_sample_counts,
20027 )
20028 .field("storage_image_sample_counts", &self.storage_image_sample_counts)
20029 .field("max_sample_mask_words", &self.max_sample_mask_words)
20030 .field(
20031 "timestamp_compute_and_graphics",
20032 &(self.timestamp_compute_and_graphics != 0),
20033 )
20034 .field("timestamp_period", &self.timestamp_period)
20035 .field("max_clip_distances", &self.max_clip_distances)
20036 .field("max_cull_distances", &self.max_cull_distances)
20037 .field(
20038 "max_combined_clip_and_cull_distances",
20039 &self.max_combined_clip_and_cull_distances,
20040 )
20041 .field("discrete_queue_priorities", &self.discrete_queue_priorities)
20042 .field("point_size_range", &self.point_size_range)
20043 .field("line_width_range", &self.line_width_range)
20044 .field("point_size_granularity", &self.point_size_granularity)
20045 .field("line_width_granularity", &self.line_width_granularity)
20046 .field("strict_lines", &(self.strict_lines != 0))
20047 .field("standard_sample_locations", &(self.standard_sample_locations != 0))
20048 .field(
20049 "optimal_buffer_copy_offset_alignment",
20050 &self.optimal_buffer_copy_offset_alignment,
20051 )
20052 .field(
20053 "optimal_buffer_copy_row_pitch_alignment",
20054 &self.optimal_buffer_copy_row_pitch_alignment,
20055 )
20056 .field("non_coherent_atom_size", &self.non_coherent_atom_size)
20057 .finish()
20058 }
20059}
20060impl PhysicalDeviceLimits {
20061 #[inline]
20062 pub fn into_builder<'a>(self) -> PhysicalDeviceLimitsBuilder<'a> {
20063 PhysicalDeviceLimitsBuilder(self, std::marker::PhantomData)
20064 }
20065}
20066#[derive(Copy, Clone)]
20067#[repr(transparent)]
20069pub struct PhysicalDeviceLimitsBuilder<'a>(
20070 PhysicalDeviceLimits,
20071 std::marker::PhantomData<&'a ()>,
20072);
20073impl<'a> PhysicalDeviceLimitsBuilder<'a> {
20074 #[inline]
20075 pub fn new() -> PhysicalDeviceLimitsBuilder<'a> {
20076 PhysicalDeviceLimitsBuilder(Default::default(), std::marker::PhantomData)
20077 }
20078 #[inline]
20079 #[must_use]
20080 pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self {
20081 self.0.max_image_dimension1_d = max_image_dimension1_d as _;
20082 self
20083 }
20084 #[inline]
20085 #[must_use]
20086 pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self {
20087 self.0.max_image_dimension2_d = max_image_dimension2_d as _;
20088 self
20089 }
20090 #[inline]
20091 #[must_use]
20092 pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self {
20093 self.0.max_image_dimension3_d = max_image_dimension3_d as _;
20094 self
20095 }
20096 #[inline]
20097 #[must_use]
20098 pub fn max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self {
20099 self.0.max_image_dimension_cube = max_image_dimension_cube as _;
20100 self
20101 }
20102 #[inline]
20103 #[must_use]
20104 pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
20105 self.0.max_image_array_layers = max_image_array_layers as _;
20106 self
20107 }
20108 #[inline]
20109 #[must_use]
20110 pub fn max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self {
20111 self.0.max_texel_buffer_elements = max_texel_buffer_elements as _;
20112 self
20113 }
20114 #[inline]
20115 #[must_use]
20116 pub fn max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self {
20117 self.0.max_uniform_buffer_range = max_uniform_buffer_range as _;
20118 self
20119 }
20120 #[inline]
20121 #[must_use]
20122 pub fn max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self {
20123 self.0.max_storage_buffer_range = max_storage_buffer_range as _;
20124 self
20125 }
20126 #[inline]
20127 #[must_use]
20128 pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self {
20129 self.0.max_push_constants_size = max_push_constants_size as _;
20130 self
20131 }
20132 #[inline]
20133 #[must_use]
20134 pub fn max_memory_allocation_count(
20135 mut self,
20136 max_memory_allocation_count: u32,
20137 ) -> Self {
20138 self.0.max_memory_allocation_count = max_memory_allocation_count as _;
20139 self
20140 }
20141 #[inline]
20142 #[must_use]
20143 pub fn max_sampler_allocation_count(
20144 mut self,
20145 max_sampler_allocation_count: u32,
20146 ) -> Self {
20147 self.0.max_sampler_allocation_count = max_sampler_allocation_count as _;
20148 self
20149 }
20150 #[inline]
20151 #[must_use]
20152 pub fn buffer_image_granularity(
20153 mut self,
20154 buffer_image_granularity: crate::vk1_0::DeviceSize,
20155 ) -> Self {
20156 self.0.buffer_image_granularity = buffer_image_granularity as _;
20157 self
20158 }
20159 #[inline]
20160 #[must_use]
20161 pub fn sparse_address_space_size(
20162 mut self,
20163 sparse_address_space_size: crate::vk1_0::DeviceSize,
20164 ) -> Self {
20165 self.0.sparse_address_space_size = sparse_address_space_size as _;
20166 self
20167 }
20168 #[inline]
20169 #[must_use]
20170 pub fn max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self {
20171 self.0.max_bound_descriptor_sets = max_bound_descriptor_sets as _;
20172 self
20173 }
20174 #[inline]
20175 #[must_use]
20176 pub fn max_per_stage_descriptor_samplers(
20177 mut self,
20178 max_per_stage_descriptor_samplers: u32,
20179 ) -> Self {
20180 self
20181 .0
20182 .max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers as _;
20183 self
20184 }
20185 #[inline]
20186 #[must_use]
20187 pub fn max_per_stage_descriptor_uniform_buffers(
20188 mut self,
20189 max_per_stage_descriptor_uniform_buffers: u32,
20190 ) -> Self {
20191 self
20192 .0
20193 .max_per_stage_descriptor_uniform_buffers = max_per_stage_descriptor_uniform_buffers
20194 as _;
20195 self
20196 }
20197 #[inline]
20198 #[must_use]
20199 pub fn max_per_stage_descriptor_storage_buffers(
20200 mut self,
20201 max_per_stage_descriptor_storage_buffers: u32,
20202 ) -> Self {
20203 self
20204 .0
20205 .max_per_stage_descriptor_storage_buffers = max_per_stage_descriptor_storage_buffers
20206 as _;
20207 self
20208 }
20209 #[inline]
20210 #[must_use]
20211 pub fn max_per_stage_descriptor_sampled_images(
20212 mut self,
20213 max_per_stage_descriptor_sampled_images: u32,
20214 ) -> Self {
20215 self
20216 .0
20217 .max_per_stage_descriptor_sampled_images = max_per_stage_descriptor_sampled_images
20218 as _;
20219 self
20220 }
20221 #[inline]
20222 #[must_use]
20223 pub fn max_per_stage_descriptor_storage_images(
20224 mut self,
20225 max_per_stage_descriptor_storage_images: u32,
20226 ) -> Self {
20227 self
20228 .0
20229 .max_per_stage_descriptor_storage_images = max_per_stage_descriptor_storage_images
20230 as _;
20231 self
20232 }
20233 #[inline]
20234 #[must_use]
20235 pub fn max_per_stage_descriptor_input_attachments(
20236 mut self,
20237 max_per_stage_descriptor_input_attachments: u32,
20238 ) -> Self {
20239 self
20240 .0
20241 .max_per_stage_descriptor_input_attachments = max_per_stage_descriptor_input_attachments
20242 as _;
20243 self
20244 }
20245 #[inline]
20246 #[must_use]
20247 pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self {
20248 self.0.max_per_stage_resources = max_per_stage_resources as _;
20249 self
20250 }
20251 #[inline]
20252 #[must_use]
20253 pub fn max_descriptor_set_samplers(
20254 mut self,
20255 max_descriptor_set_samplers: u32,
20256 ) -> Self {
20257 self.0.max_descriptor_set_samplers = max_descriptor_set_samplers as _;
20258 self
20259 }
20260 #[inline]
20261 #[must_use]
20262 pub fn max_descriptor_set_uniform_buffers(
20263 mut self,
20264 max_descriptor_set_uniform_buffers: u32,
20265 ) -> Self {
20266 self
20267 .0
20268 .max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers
20269 as _;
20270 self
20271 }
20272 #[inline]
20273 #[must_use]
20274 pub fn max_descriptor_set_uniform_buffers_dynamic(
20275 mut self,
20276 max_descriptor_set_uniform_buffers_dynamic: u32,
20277 ) -> Self {
20278 self
20279 .0
20280 .max_descriptor_set_uniform_buffers_dynamic = max_descriptor_set_uniform_buffers_dynamic
20281 as _;
20282 self
20283 }
20284 #[inline]
20285 #[must_use]
20286 pub fn max_descriptor_set_storage_buffers(
20287 mut self,
20288 max_descriptor_set_storage_buffers: u32,
20289 ) -> Self {
20290 self
20291 .0
20292 .max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers
20293 as _;
20294 self
20295 }
20296 #[inline]
20297 #[must_use]
20298 pub fn max_descriptor_set_storage_buffers_dynamic(
20299 mut self,
20300 max_descriptor_set_storage_buffers_dynamic: u32,
20301 ) -> Self {
20302 self
20303 .0
20304 .max_descriptor_set_storage_buffers_dynamic = max_descriptor_set_storage_buffers_dynamic
20305 as _;
20306 self
20307 }
20308 #[inline]
20309 #[must_use]
20310 pub fn max_descriptor_set_sampled_images(
20311 mut self,
20312 max_descriptor_set_sampled_images: u32,
20313 ) -> Self {
20314 self
20315 .0
20316 .max_descriptor_set_sampled_images = max_descriptor_set_sampled_images as _;
20317 self
20318 }
20319 #[inline]
20320 #[must_use]
20321 pub fn max_descriptor_set_storage_images(
20322 mut self,
20323 max_descriptor_set_storage_images: u32,
20324 ) -> Self {
20325 self
20326 .0
20327 .max_descriptor_set_storage_images = max_descriptor_set_storage_images as _;
20328 self
20329 }
20330 #[inline]
20331 #[must_use]
20332 pub fn max_descriptor_set_input_attachments(
20333 mut self,
20334 max_descriptor_set_input_attachments: u32,
20335 ) -> Self {
20336 self
20337 .0
20338 .max_descriptor_set_input_attachments = max_descriptor_set_input_attachments
20339 as _;
20340 self
20341 }
20342 #[inline]
20343 #[must_use]
20344 pub fn max_vertex_input_attributes(
20345 mut self,
20346 max_vertex_input_attributes: u32,
20347 ) -> Self {
20348 self.0.max_vertex_input_attributes = max_vertex_input_attributes as _;
20349 self
20350 }
20351 #[inline]
20352 #[must_use]
20353 pub fn max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self {
20354 self.0.max_vertex_input_bindings = max_vertex_input_bindings as _;
20355 self
20356 }
20357 #[inline]
20358 #[must_use]
20359 pub fn max_vertex_input_attribute_offset(
20360 mut self,
20361 max_vertex_input_attribute_offset: u32,
20362 ) -> Self {
20363 self
20364 .0
20365 .max_vertex_input_attribute_offset = max_vertex_input_attribute_offset as _;
20366 self
20367 }
20368 #[inline]
20369 #[must_use]
20370 pub fn max_vertex_input_binding_stride(
20371 mut self,
20372 max_vertex_input_binding_stride: u32,
20373 ) -> Self {
20374 self.0.max_vertex_input_binding_stride = max_vertex_input_binding_stride as _;
20375 self
20376 }
20377 #[inline]
20378 #[must_use]
20379 pub fn max_vertex_output_components(
20380 mut self,
20381 max_vertex_output_components: u32,
20382 ) -> Self {
20383 self.0.max_vertex_output_components = max_vertex_output_components as _;
20384 self
20385 }
20386 #[inline]
20387 #[must_use]
20388 pub fn max_tessellation_generation_level(
20389 mut self,
20390 max_tessellation_generation_level: u32,
20391 ) -> Self {
20392 self
20393 .0
20394 .max_tessellation_generation_level = max_tessellation_generation_level as _;
20395 self
20396 }
20397 #[inline]
20398 #[must_use]
20399 pub fn max_tessellation_patch_size(
20400 mut self,
20401 max_tessellation_patch_size: u32,
20402 ) -> Self {
20403 self.0.max_tessellation_patch_size = max_tessellation_patch_size as _;
20404 self
20405 }
20406 #[inline]
20407 #[must_use]
20408 pub fn max_tessellation_control_per_vertex_input_components(
20409 mut self,
20410 max_tessellation_control_per_vertex_input_components: u32,
20411 ) -> Self {
20412 self
20413 .0
20414 .max_tessellation_control_per_vertex_input_components = max_tessellation_control_per_vertex_input_components
20415 as _;
20416 self
20417 }
20418 #[inline]
20419 #[must_use]
20420 pub fn max_tessellation_control_per_vertex_output_components(
20421 mut self,
20422 max_tessellation_control_per_vertex_output_components: u32,
20423 ) -> Self {
20424 self
20425 .0
20426 .max_tessellation_control_per_vertex_output_components = max_tessellation_control_per_vertex_output_components
20427 as _;
20428 self
20429 }
20430 #[inline]
20431 #[must_use]
20432 pub fn max_tessellation_control_per_patch_output_components(
20433 mut self,
20434 max_tessellation_control_per_patch_output_components: u32,
20435 ) -> Self {
20436 self
20437 .0
20438 .max_tessellation_control_per_patch_output_components = max_tessellation_control_per_patch_output_components
20439 as _;
20440 self
20441 }
20442 #[inline]
20443 #[must_use]
20444 pub fn max_tessellation_control_total_output_components(
20445 mut self,
20446 max_tessellation_control_total_output_components: u32,
20447 ) -> Self {
20448 self
20449 .0
20450 .max_tessellation_control_total_output_components = max_tessellation_control_total_output_components
20451 as _;
20452 self
20453 }
20454 #[inline]
20455 #[must_use]
20456 pub fn max_tessellation_evaluation_input_components(
20457 mut self,
20458 max_tessellation_evaluation_input_components: u32,
20459 ) -> Self {
20460 self
20461 .0
20462 .max_tessellation_evaluation_input_components = max_tessellation_evaluation_input_components
20463 as _;
20464 self
20465 }
20466 #[inline]
20467 #[must_use]
20468 pub fn max_tessellation_evaluation_output_components(
20469 mut self,
20470 max_tessellation_evaluation_output_components: u32,
20471 ) -> Self {
20472 self
20473 .0
20474 .max_tessellation_evaluation_output_components = max_tessellation_evaluation_output_components
20475 as _;
20476 self
20477 }
20478 #[inline]
20479 #[must_use]
20480 pub fn max_geometry_shader_invocations(
20481 mut self,
20482 max_geometry_shader_invocations: u32,
20483 ) -> Self {
20484 self.0.max_geometry_shader_invocations = max_geometry_shader_invocations as _;
20485 self
20486 }
20487 #[inline]
20488 #[must_use]
20489 pub fn max_geometry_input_components(
20490 mut self,
20491 max_geometry_input_components: u32,
20492 ) -> Self {
20493 self.0.max_geometry_input_components = max_geometry_input_components as _;
20494 self
20495 }
20496 #[inline]
20497 #[must_use]
20498 pub fn max_geometry_output_components(
20499 mut self,
20500 max_geometry_output_components: u32,
20501 ) -> Self {
20502 self.0.max_geometry_output_components = max_geometry_output_components as _;
20503 self
20504 }
20505 #[inline]
20506 #[must_use]
20507 pub fn max_geometry_output_vertices(
20508 mut self,
20509 max_geometry_output_vertices: u32,
20510 ) -> Self {
20511 self.0.max_geometry_output_vertices = max_geometry_output_vertices as _;
20512 self
20513 }
20514 #[inline]
20515 #[must_use]
20516 pub fn max_geometry_total_output_components(
20517 mut self,
20518 max_geometry_total_output_components: u32,
20519 ) -> Self {
20520 self
20521 .0
20522 .max_geometry_total_output_components = max_geometry_total_output_components
20523 as _;
20524 self
20525 }
20526 #[inline]
20527 #[must_use]
20528 pub fn max_fragment_input_components(
20529 mut self,
20530 max_fragment_input_components: u32,
20531 ) -> Self {
20532 self.0.max_fragment_input_components = max_fragment_input_components as _;
20533 self
20534 }
20535 #[inline]
20536 #[must_use]
20537 pub fn max_fragment_output_attachments(
20538 mut self,
20539 max_fragment_output_attachments: u32,
20540 ) -> Self {
20541 self.0.max_fragment_output_attachments = max_fragment_output_attachments as _;
20542 self
20543 }
20544 #[inline]
20545 #[must_use]
20546 pub fn max_fragment_dual_src_attachments(
20547 mut self,
20548 max_fragment_dual_src_attachments: u32,
20549 ) -> Self {
20550 self
20551 .0
20552 .max_fragment_dual_src_attachments = max_fragment_dual_src_attachments as _;
20553 self
20554 }
20555 #[inline]
20556 #[must_use]
20557 pub fn max_fragment_combined_output_resources(
20558 mut self,
20559 max_fragment_combined_output_resources: u32,
20560 ) -> Self {
20561 self
20562 .0
20563 .max_fragment_combined_output_resources = max_fragment_combined_output_resources
20564 as _;
20565 self
20566 }
20567 #[inline]
20568 #[must_use]
20569 pub fn max_compute_shared_memory_size(
20570 mut self,
20571 max_compute_shared_memory_size: u32,
20572 ) -> Self {
20573 self.0.max_compute_shared_memory_size = max_compute_shared_memory_size as _;
20574 self
20575 }
20576 #[inline]
20577 #[must_use]
20578 pub fn max_compute_work_group_count(
20579 mut self,
20580 max_compute_work_group_count: [u32; 3],
20581 ) -> Self {
20582 self.0.max_compute_work_group_count = max_compute_work_group_count as _;
20583 self
20584 }
20585 #[inline]
20586 #[must_use]
20587 pub fn max_compute_work_group_invocations(
20588 mut self,
20589 max_compute_work_group_invocations: u32,
20590 ) -> Self {
20591 self
20592 .0
20593 .max_compute_work_group_invocations = max_compute_work_group_invocations
20594 as _;
20595 self
20596 }
20597 #[inline]
20598 #[must_use]
20599 pub fn max_compute_work_group_size(
20600 mut self,
20601 max_compute_work_group_size: [u32; 3],
20602 ) -> Self {
20603 self.0.max_compute_work_group_size = max_compute_work_group_size as _;
20604 self
20605 }
20606 #[inline]
20607 #[must_use]
20608 pub fn sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self {
20609 self.0.sub_pixel_precision_bits = sub_pixel_precision_bits as _;
20610 self
20611 }
20612 #[inline]
20613 #[must_use]
20614 pub fn sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self {
20615 self.0.sub_texel_precision_bits = sub_texel_precision_bits as _;
20616 self
20617 }
20618 #[inline]
20619 #[must_use]
20620 pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self {
20621 self.0.mipmap_precision_bits = mipmap_precision_bits as _;
20622 self
20623 }
20624 #[inline]
20625 #[must_use]
20626 pub fn max_draw_indexed_index_value(
20627 mut self,
20628 max_draw_indexed_index_value: u32,
20629 ) -> Self {
20630 self.0.max_draw_indexed_index_value = max_draw_indexed_index_value as _;
20631 self
20632 }
20633 #[inline]
20634 #[must_use]
20635 pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self {
20636 self.0.max_draw_indirect_count = max_draw_indirect_count as _;
20637 self
20638 }
20639 #[inline]
20640 #[must_use]
20641 pub fn max_sampler_lod_bias(
20642 mut self,
20643 max_sampler_lod_bias: std::os::raw::c_float,
20644 ) -> Self {
20645 self.0.max_sampler_lod_bias = max_sampler_lod_bias as _;
20646 self
20647 }
20648 #[inline]
20649 #[must_use]
20650 pub fn max_sampler_anisotropy(
20651 mut self,
20652 max_sampler_anisotropy: std::os::raw::c_float,
20653 ) -> Self {
20654 self.0.max_sampler_anisotropy = max_sampler_anisotropy as _;
20655 self
20656 }
20657 #[inline]
20658 #[must_use]
20659 pub fn max_viewports(mut self, max_viewports: u32) -> Self {
20660 self.0.max_viewports = max_viewports as _;
20661 self
20662 }
20663 #[inline]
20664 #[must_use]
20665 pub fn max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self {
20666 self.0.max_viewport_dimensions = max_viewport_dimensions as _;
20667 self
20668 }
20669 #[inline]
20670 #[must_use]
20671 pub fn viewport_bounds_range(
20672 mut self,
20673 viewport_bounds_range: [std::os::raw::c_float; 2],
20674 ) -> Self {
20675 self.0.viewport_bounds_range = viewport_bounds_range as _;
20676 self
20677 }
20678 #[inline]
20679 #[must_use]
20680 pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self {
20681 self.0.viewport_sub_pixel_bits = viewport_sub_pixel_bits as _;
20682 self
20683 }
20684 #[inline]
20685 #[must_use]
20686 pub fn min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self {
20687 self.0.min_memory_map_alignment = min_memory_map_alignment as _;
20688 self
20689 }
20690 #[inline]
20691 #[must_use]
20692 pub fn min_texel_buffer_offset_alignment(
20693 mut self,
20694 min_texel_buffer_offset_alignment: crate::vk1_0::DeviceSize,
20695 ) -> Self {
20696 self
20697 .0
20698 .min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment as _;
20699 self
20700 }
20701 #[inline]
20702 #[must_use]
20703 pub fn min_uniform_buffer_offset_alignment(
20704 mut self,
20705 min_uniform_buffer_offset_alignment: crate::vk1_0::DeviceSize,
20706 ) -> Self {
20707 self
20708 .0
20709 .min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment
20710 as _;
20711 self
20712 }
20713 #[inline]
20714 #[must_use]
20715 pub fn min_storage_buffer_offset_alignment(
20716 mut self,
20717 min_storage_buffer_offset_alignment: crate::vk1_0::DeviceSize,
20718 ) -> Self {
20719 self
20720 .0
20721 .min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment
20722 as _;
20723 self
20724 }
20725 #[inline]
20726 #[must_use]
20727 pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self {
20728 self.0.min_texel_offset = min_texel_offset as _;
20729 self
20730 }
20731 #[inline]
20732 #[must_use]
20733 pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self {
20734 self.0.max_texel_offset = max_texel_offset as _;
20735 self
20736 }
20737 #[inline]
20738 #[must_use]
20739 pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self {
20740 self.0.min_texel_gather_offset = min_texel_gather_offset as _;
20741 self
20742 }
20743 #[inline]
20744 #[must_use]
20745 pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self {
20746 self.0.max_texel_gather_offset = max_texel_gather_offset as _;
20747 self
20748 }
20749 #[inline]
20750 #[must_use]
20751 pub fn min_interpolation_offset(
20752 mut self,
20753 min_interpolation_offset: std::os::raw::c_float,
20754 ) -> Self {
20755 self.0.min_interpolation_offset = min_interpolation_offset as _;
20756 self
20757 }
20758 #[inline]
20759 #[must_use]
20760 pub fn max_interpolation_offset(
20761 mut self,
20762 max_interpolation_offset: std::os::raw::c_float,
20763 ) -> Self {
20764 self.0.max_interpolation_offset = max_interpolation_offset as _;
20765 self
20766 }
20767 #[inline]
20768 #[must_use]
20769 pub fn sub_pixel_interpolation_offset_bits(
20770 mut self,
20771 sub_pixel_interpolation_offset_bits: u32,
20772 ) -> Self {
20773 self
20774 .0
20775 .sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits
20776 as _;
20777 self
20778 }
20779 #[inline]
20780 #[must_use]
20781 pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self {
20782 self.0.max_framebuffer_width = max_framebuffer_width as _;
20783 self
20784 }
20785 #[inline]
20786 #[must_use]
20787 pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self {
20788 self.0.max_framebuffer_height = max_framebuffer_height as _;
20789 self
20790 }
20791 #[inline]
20792 #[must_use]
20793 pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self {
20794 self.0.max_framebuffer_layers = max_framebuffer_layers as _;
20795 self
20796 }
20797 #[inline]
20798 #[must_use]
20799 pub fn framebuffer_color_sample_counts(
20800 mut self,
20801 framebuffer_color_sample_counts: crate::vk1_0::SampleCountFlags,
20802 ) -> Self {
20803 self.0.framebuffer_color_sample_counts = framebuffer_color_sample_counts as _;
20804 self
20805 }
20806 #[inline]
20807 #[must_use]
20808 pub fn framebuffer_depth_sample_counts(
20809 mut self,
20810 framebuffer_depth_sample_counts: crate::vk1_0::SampleCountFlags,
20811 ) -> Self {
20812 self.0.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts as _;
20813 self
20814 }
20815 #[inline]
20816 #[must_use]
20817 pub fn framebuffer_stencil_sample_counts(
20818 mut self,
20819 framebuffer_stencil_sample_counts: crate::vk1_0::SampleCountFlags,
20820 ) -> Self {
20821 self
20822 .0
20823 .framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts as _;
20824 self
20825 }
20826 #[inline]
20827 #[must_use]
20828 pub fn framebuffer_no_attachments_sample_counts(
20829 mut self,
20830 framebuffer_no_attachments_sample_counts: crate::vk1_0::SampleCountFlags,
20831 ) -> Self {
20832 self
20833 .0
20834 .framebuffer_no_attachments_sample_counts = framebuffer_no_attachments_sample_counts
20835 as _;
20836 self
20837 }
20838 #[inline]
20839 #[must_use]
20840 pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self {
20841 self.0.max_color_attachments = max_color_attachments as _;
20842 self
20843 }
20844 #[inline]
20845 #[must_use]
20846 pub fn sampled_image_color_sample_counts(
20847 mut self,
20848 sampled_image_color_sample_counts: crate::vk1_0::SampleCountFlags,
20849 ) -> Self {
20850 self
20851 .0
20852 .sampled_image_color_sample_counts = sampled_image_color_sample_counts as _;
20853 self
20854 }
20855 #[inline]
20856 #[must_use]
20857 pub fn sampled_image_integer_sample_counts(
20858 mut self,
20859 sampled_image_integer_sample_counts: crate::vk1_0::SampleCountFlags,
20860 ) -> Self {
20861 self
20862 .0
20863 .sampled_image_integer_sample_counts = sampled_image_integer_sample_counts
20864 as _;
20865 self
20866 }
20867 #[inline]
20868 #[must_use]
20869 pub fn sampled_image_depth_sample_counts(
20870 mut self,
20871 sampled_image_depth_sample_counts: crate::vk1_0::SampleCountFlags,
20872 ) -> Self {
20873 self
20874 .0
20875 .sampled_image_depth_sample_counts = sampled_image_depth_sample_counts as _;
20876 self
20877 }
20878 #[inline]
20879 #[must_use]
20880 pub fn sampled_image_stencil_sample_counts(
20881 mut self,
20882 sampled_image_stencil_sample_counts: crate::vk1_0::SampleCountFlags,
20883 ) -> Self {
20884 self
20885 .0
20886 .sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts
20887 as _;
20888 self
20889 }
20890 #[inline]
20891 #[must_use]
20892 pub fn storage_image_sample_counts(
20893 mut self,
20894 storage_image_sample_counts: crate::vk1_0::SampleCountFlags,
20895 ) -> Self {
20896 self.0.storage_image_sample_counts = storage_image_sample_counts as _;
20897 self
20898 }
20899 #[inline]
20900 #[must_use]
20901 pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self {
20902 self.0.max_sample_mask_words = max_sample_mask_words as _;
20903 self
20904 }
20905 #[inline]
20906 #[must_use]
20907 pub fn timestamp_compute_and_graphics(
20908 mut self,
20909 timestamp_compute_and_graphics: bool,
20910 ) -> Self {
20911 self.0.timestamp_compute_and_graphics = timestamp_compute_and_graphics as _;
20912 self
20913 }
20914 #[inline]
20915 #[must_use]
20916 pub fn timestamp_period(mut self, timestamp_period: std::os::raw::c_float) -> Self {
20917 self.0.timestamp_period = timestamp_period as _;
20918 self
20919 }
20920 #[inline]
20921 #[must_use]
20922 pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self {
20923 self.0.max_clip_distances = max_clip_distances as _;
20924 self
20925 }
20926 #[inline]
20927 #[must_use]
20928 pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self {
20929 self.0.max_cull_distances = max_cull_distances as _;
20930 self
20931 }
20932 #[inline]
20933 #[must_use]
20934 pub fn max_combined_clip_and_cull_distances(
20935 mut self,
20936 max_combined_clip_and_cull_distances: u32,
20937 ) -> Self {
20938 self
20939 .0
20940 .max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances
20941 as _;
20942 self
20943 }
20944 #[inline]
20945 #[must_use]
20946 pub fn discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self {
20947 self.0.discrete_queue_priorities = discrete_queue_priorities as _;
20948 self
20949 }
20950 #[inline]
20951 #[must_use]
20952 pub fn point_size_range(
20953 mut self,
20954 point_size_range: [std::os::raw::c_float; 2],
20955 ) -> Self {
20956 self.0.point_size_range = point_size_range as _;
20957 self
20958 }
20959 #[inline]
20960 #[must_use]
20961 pub fn line_width_range(
20962 mut self,
20963 line_width_range: [std::os::raw::c_float; 2],
20964 ) -> Self {
20965 self.0.line_width_range = line_width_range as _;
20966 self
20967 }
20968 #[inline]
20969 #[must_use]
20970 pub fn point_size_granularity(
20971 mut self,
20972 point_size_granularity: std::os::raw::c_float,
20973 ) -> Self {
20974 self.0.point_size_granularity = point_size_granularity as _;
20975 self
20976 }
20977 #[inline]
20978 #[must_use]
20979 pub fn line_width_granularity(
20980 mut self,
20981 line_width_granularity: std::os::raw::c_float,
20982 ) -> Self {
20983 self.0.line_width_granularity = line_width_granularity as _;
20984 self
20985 }
20986 #[inline]
20987 #[must_use]
20988 pub fn strict_lines(mut self, strict_lines: bool) -> Self {
20989 self.0.strict_lines = strict_lines as _;
20990 self
20991 }
20992 #[inline]
20993 #[must_use]
20994 pub fn standard_sample_locations(mut self, standard_sample_locations: bool) -> Self {
20995 self.0.standard_sample_locations = standard_sample_locations as _;
20996 self
20997 }
20998 #[inline]
20999 #[must_use]
21000 pub fn optimal_buffer_copy_offset_alignment(
21001 mut self,
21002 optimal_buffer_copy_offset_alignment: crate::vk1_0::DeviceSize,
21003 ) -> Self {
21004 self
21005 .0
21006 .optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment
21007 as _;
21008 self
21009 }
21010 #[inline]
21011 #[must_use]
21012 pub fn optimal_buffer_copy_row_pitch_alignment(
21013 mut self,
21014 optimal_buffer_copy_row_pitch_alignment: crate::vk1_0::DeviceSize,
21015 ) -> Self {
21016 self
21017 .0
21018 .optimal_buffer_copy_row_pitch_alignment = optimal_buffer_copy_row_pitch_alignment
21019 as _;
21020 self
21021 }
21022 #[inline]
21023 #[must_use]
21024 pub fn non_coherent_atom_size(
21025 mut self,
21026 non_coherent_atom_size: crate::vk1_0::DeviceSize,
21027 ) -> Self {
21028 self.0.non_coherent_atom_size = non_coherent_atom_size as _;
21029 self
21030 }
21031 #[inline]
21032 pub fn build(self) -> PhysicalDeviceLimits {
21033 self.0
21034 }
21035}
21036impl<'a> std::default::Default for PhysicalDeviceLimitsBuilder<'a> {
21037 fn default() -> PhysicalDeviceLimitsBuilder<'a> {
21038 Self::new()
21039 }
21040}
21041impl<'a> std::fmt::Debug for PhysicalDeviceLimitsBuilder<'a> {
21042 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21043 std::fmt::Debug::fmt(&self.0, f)
21044 }
21045}
21046impl<'a> std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> {
21047 type Target = PhysicalDeviceLimits;
21048 fn deref(&self) -> &Self::Target {
21049 &self.0
21050 }
21051}
21052impl<'a> std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> {
21053 fn deref_mut(&mut self) -> &mut Self::Target {
21054 &mut self.0
21055 }
21056}
21057#[doc(alias = "VkSemaphoreCreateInfo")]
21059#[derive(Copy, Clone)]
21060#[repr(C)]
21061pub struct SemaphoreCreateInfo {
21062 pub s_type: crate::vk1_0::StructureType,
21063 pub p_next: *const std::ffi::c_void,
21064 pub flags: crate::vk1_0::SemaphoreCreateFlags,
21065}
21066impl SemaphoreCreateInfo {
21067 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::SEMAPHORE_CREATE_INFO;
21068}
21069impl Default for SemaphoreCreateInfo {
21070 fn default() -> Self {
21071 Self {
21072 s_type: Self::STRUCTURE_TYPE,
21073 p_next: std::ptr::null(),
21074 flags: Default::default(),
21075 }
21076 }
21077}
21078impl std::fmt::Debug for SemaphoreCreateInfo {
21079 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21080 f.debug_struct("SemaphoreCreateInfo")
21081 .field("s_type", &self.s_type)
21082 .field("p_next", &self.p_next)
21083 .field("flags", &self.flags)
21084 .finish()
21085 }
21086}
21087impl SemaphoreCreateInfo {
21088 #[inline]
21089 pub fn into_builder<'a>(self) -> SemaphoreCreateInfoBuilder<'a> {
21090 SemaphoreCreateInfoBuilder(self, std::marker::PhantomData)
21091 }
21092}
21093#[derive(Copy, Clone)]
21094#[repr(transparent)]
21096pub struct SemaphoreCreateInfoBuilder<'a>(
21097 SemaphoreCreateInfo,
21098 std::marker::PhantomData<&'a ()>,
21099);
21100impl<'a> SemaphoreCreateInfoBuilder<'a> {
21101 #[inline]
21102 pub fn new() -> SemaphoreCreateInfoBuilder<'a> {
21103 SemaphoreCreateInfoBuilder(Default::default(), std::marker::PhantomData)
21104 }
21105 #[inline]
21106 #[must_use]
21107 pub fn flags(mut self, flags: crate::vk1_0::SemaphoreCreateFlags) -> Self {
21108 self.0.flags = flags as _;
21109 self
21110 }
21111 #[inline]
21112 pub fn build_dangling(self) -> SemaphoreCreateInfo {
21115 self.0
21116 }
21117}
21118impl<'a> std::default::Default for SemaphoreCreateInfoBuilder<'a> {
21119 fn default() -> SemaphoreCreateInfoBuilder<'a> {
21120 Self::new()
21121 }
21122}
21123impl<'a> std::fmt::Debug for SemaphoreCreateInfoBuilder<'a> {
21124 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21125 std::fmt::Debug::fmt(&self.0, f)
21126 }
21127}
21128impl<'a> std::ops::Deref for SemaphoreCreateInfoBuilder<'a> {
21129 type Target = SemaphoreCreateInfo;
21130 fn deref(&self) -> &Self::Target {
21131 &self.0
21132 }
21133}
21134impl<'a> std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> {
21135 fn deref_mut(&mut self) -> &mut Self::Target {
21136 &mut self.0
21137 }
21138}
21139#[doc(alias = "VkQueryPoolCreateInfo")]
21141#[derive(Copy, Clone)]
21142#[repr(C)]
21143pub struct QueryPoolCreateInfo {
21144 pub s_type: crate::vk1_0::StructureType,
21145 pub p_next: *const std::ffi::c_void,
21146 pub flags: crate::vk1_0::QueryPoolCreateFlags,
21147 pub query_type: crate::vk1_0::QueryType,
21148 pub query_count: u32,
21149 pub pipeline_statistics: crate::vk1_0::QueryPipelineStatisticFlags,
21150}
21151impl QueryPoolCreateInfo {
21152 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::QUERY_POOL_CREATE_INFO;
21153}
21154impl Default for QueryPoolCreateInfo {
21155 fn default() -> Self {
21156 Self {
21157 s_type: Self::STRUCTURE_TYPE,
21158 p_next: std::ptr::null(),
21159 flags: Default::default(),
21160 query_type: Default::default(),
21161 query_count: Default::default(),
21162 pipeline_statistics: Default::default(),
21163 }
21164 }
21165}
21166impl std::fmt::Debug for QueryPoolCreateInfo {
21167 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21168 f.debug_struct("QueryPoolCreateInfo")
21169 .field("s_type", &self.s_type)
21170 .field("p_next", &self.p_next)
21171 .field("flags", &self.flags)
21172 .field("query_type", &self.query_type)
21173 .field("query_count", &self.query_count)
21174 .field("pipeline_statistics", &self.pipeline_statistics)
21175 .finish()
21176 }
21177}
21178impl QueryPoolCreateInfo {
21179 #[inline]
21180 pub fn into_builder<'a>(self) -> QueryPoolCreateInfoBuilder<'a> {
21181 QueryPoolCreateInfoBuilder(self, std::marker::PhantomData)
21182 }
21183}
21184#[derive(Copy, Clone)]
21185#[repr(transparent)]
21187pub struct QueryPoolCreateInfoBuilder<'a>(
21188 QueryPoolCreateInfo,
21189 std::marker::PhantomData<&'a ()>,
21190);
21191impl<'a> QueryPoolCreateInfoBuilder<'a> {
21192 #[inline]
21193 pub fn new() -> QueryPoolCreateInfoBuilder<'a> {
21194 QueryPoolCreateInfoBuilder(Default::default(), std::marker::PhantomData)
21195 }
21196 #[inline]
21197 #[must_use]
21198 pub fn flags(mut self, flags: crate::vk1_0::QueryPoolCreateFlags) -> Self {
21199 self.0.flags = flags as _;
21200 self
21201 }
21202 #[inline]
21203 #[must_use]
21204 pub fn query_type(mut self, query_type: crate::vk1_0::QueryType) -> Self {
21205 self.0.query_type = query_type as _;
21206 self
21207 }
21208 #[inline]
21209 #[must_use]
21210 pub fn query_count(mut self, query_count: u32) -> Self {
21211 self.0.query_count = query_count as _;
21212 self
21213 }
21214 #[inline]
21215 #[must_use]
21216 pub fn pipeline_statistics(
21217 mut self,
21218 pipeline_statistics: crate::vk1_0::QueryPipelineStatisticFlags,
21219 ) -> Self {
21220 self.0.pipeline_statistics = pipeline_statistics as _;
21221 self
21222 }
21223 #[inline]
21224 pub fn build_dangling(self) -> QueryPoolCreateInfo {
21227 self.0
21228 }
21229}
21230impl<'a> std::default::Default for QueryPoolCreateInfoBuilder<'a> {
21231 fn default() -> QueryPoolCreateInfoBuilder<'a> {
21232 Self::new()
21233 }
21234}
21235impl<'a> std::fmt::Debug for QueryPoolCreateInfoBuilder<'a> {
21236 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21237 std::fmt::Debug::fmt(&self.0, f)
21238 }
21239}
21240impl<'a> std::ops::Deref for QueryPoolCreateInfoBuilder<'a> {
21241 type Target = QueryPoolCreateInfo;
21242 fn deref(&self) -> &Self::Target {
21243 &self.0
21244 }
21245}
21246impl<'a> std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> {
21247 fn deref_mut(&mut self) -> &mut Self::Target {
21248 &mut self.0
21249 }
21250}
21251#[doc(alias = "VkFramebufferCreateInfo")]
21253#[derive(Copy, Clone)]
21254#[repr(C)]
21255pub struct FramebufferCreateInfo {
21256 pub s_type: crate::vk1_0::StructureType,
21257 pub p_next: *const std::ffi::c_void,
21258 pub flags: crate::vk1_0::FramebufferCreateFlags,
21259 pub render_pass: crate::vk1_0::RenderPass,
21260 pub attachment_count: u32,
21261 pub p_attachments: *const crate::vk1_0::ImageView,
21262 pub width: u32,
21263 pub height: u32,
21264 pub layers: u32,
21265}
21266impl FramebufferCreateInfo {
21267 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::FRAMEBUFFER_CREATE_INFO;
21268}
21269impl Default for FramebufferCreateInfo {
21270 fn default() -> Self {
21271 Self {
21272 s_type: Self::STRUCTURE_TYPE,
21273 p_next: std::ptr::null(),
21274 flags: Default::default(),
21275 render_pass: Default::default(),
21276 attachment_count: Default::default(),
21277 p_attachments: std::ptr::null(),
21278 width: Default::default(),
21279 height: Default::default(),
21280 layers: Default::default(),
21281 }
21282 }
21283}
21284impl std::fmt::Debug for FramebufferCreateInfo {
21285 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21286 f.debug_struct("FramebufferCreateInfo")
21287 .field("s_type", &self.s_type)
21288 .field("p_next", &self.p_next)
21289 .field("flags", &self.flags)
21290 .field("render_pass", &self.render_pass)
21291 .field("attachment_count", &self.attachment_count)
21292 .field("p_attachments", &self.p_attachments)
21293 .field("width", &self.width)
21294 .field("height", &self.height)
21295 .field("layers", &self.layers)
21296 .finish()
21297 }
21298}
21299impl FramebufferCreateInfo {
21300 #[inline]
21301 pub fn into_builder<'a>(self) -> FramebufferCreateInfoBuilder<'a> {
21302 FramebufferCreateInfoBuilder(self, std::marker::PhantomData)
21303 }
21304}
21305#[derive(Copy, Clone)]
21306#[repr(transparent)]
21308pub struct FramebufferCreateInfoBuilder<'a>(
21309 FramebufferCreateInfo,
21310 std::marker::PhantomData<&'a ()>,
21311);
21312impl<'a> FramebufferCreateInfoBuilder<'a> {
21313 #[inline]
21314 pub fn new() -> FramebufferCreateInfoBuilder<'a> {
21315 FramebufferCreateInfoBuilder(Default::default(), std::marker::PhantomData)
21316 }
21317 #[inline]
21318 #[must_use]
21319 pub fn flags(mut self, flags: crate::vk1_0::FramebufferCreateFlags) -> Self {
21320 self.0.flags = flags as _;
21321 self
21322 }
21323 #[inline]
21324 #[must_use]
21325 pub fn render_pass(mut self, render_pass: crate::vk1_0::RenderPass) -> Self {
21326 self.0.render_pass = render_pass as _;
21327 self
21328 }
21329 #[inline]
21330 #[must_use]
21331 pub fn attachment_count(mut self, attachment_count: u32) -> Self {
21332 self.0.attachment_count = attachment_count as _;
21333 self
21334 }
21335 #[inline]
21336 #[must_use]
21337 pub fn attachments(mut self, attachments: &'a [crate::vk1_0::ImageView]) -> Self {
21338 self.0.p_attachments = attachments.as_ptr() as _;
21339 self.0.attachment_count = attachments.len() as _;
21340 self
21341 }
21342 #[inline]
21343 #[must_use]
21344 pub fn width(mut self, width: u32) -> Self {
21345 self.0.width = width as _;
21346 self
21347 }
21348 #[inline]
21349 #[must_use]
21350 pub fn height(mut self, height: u32) -> Self {
21351 self.0.height = height as _;
21352 self
21353 }
21354 #[inline]
21355 #[must_use]
21356 pub fn layers(mut self, layers: u32) -> Self {
21357 self.0.layers = layers as _;
21358 self
21359 }
21360 #[inline]
21361 pub fn build_dangling(self) -> FramebufferCreateInfo {
21364 self.0
21365 }
21366}
21367impl<'a> std::default::Default for FramebufferCreateInfoBuilder<'a> {
21368 fn default() -> FramebufferCreateInfoBuilder<'a> {
21369 Self::new()
21370 }
21371}
21372impl<'a> std::fmt::Debug for FramebufferCreateInfoBuilder<'a> {
21373 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21374 std::fmt::Debug::fmt(&self.0, f)
21375 }
21376}
21377impl<'a> std::ops::Deref for FramebufferCreateInfoBuilder<'a> {
21378 type Target = FramebufferCreateInfo;
21379 fn deref(&self) -> &Self::Target {
21380 &self.0
21381 }
21382}
21383impl<'a> std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> {
21384 fn deref_mut(&mut self) -> &mut Self::Target {
21385 &mut self.0
21386 }
21387}
21388#[doc(alias = "VkDrawIndirectCommand")]
21390#[derive(Copy, Clone, Hash, PartialEq, Eq)]
21391#[repr(C)]
21392pub struct DrawIndirectCommand {
21393 pub vertex_count: u32,
21394 pub instance_count: u32,
21395 pub first_vertex: u32,
21396 pub first_instance: u32,
21397}
21398impl Default for DrawIndirectCommand {
21399 fn default() -> Self {
21400 Self {
21401 vertex_count: Default::default(),
21402 instance_count: Default::default(),
21403 first_vertex: Default::default(),
21404 first_instance: Default::default(),
21405 }
21406 }
21407}
21408impl std::fmt::Debug for DrawIndirectCommand {
21409 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21410 f.debug_struct("DrawIndirectCommand")
21411 .field("vertex_count", &self.vertex_count)
21412 .field("instance_count", &self.instance_count)
21413 .field("first_vertex", &self.first_vertex)
21414 .field("first_instance", &self.first_instance)
21415 .finish()
21416 }
21417}
21418impl DrawIndirectCommand {
21419 #[inline]
21420 pub fn into_builder<'a>(self) -> DrawIndirectCommandBuilder<'a> {
21421 DrawIndirectCommandBuilder(self, std::marker::PhantomData)
21422 }
21423}
21424#[derive(Copy, Clone)]
21425#[repr(transparent)]
21427pub struct DrawIndirectCommandBuilder<'a>(
21428 DrawIndirectCommand,
21429 std::marker::PhantomData<&'a ()>,
21430);
21431impl<'a> DrawIndirectCommandBuilder<'a> {
21432 #[inline]
21433 pub fn new() -> DrawIndirectCommandBuilder<'a> {
21434 DrawIndirectCommandBuilder(Default::default(), std::marker::PhantomData)
21435 }
21436 #[inline]
21437 #[must_use]
21438 pub fn vertex_count(mut self, vertex_count: u32) -> Self {
21439 self.0.vertex_count = vertex_count as _;
21440 self
21441 }
21442 #[inline]
21443 #[must_use]
21444 pub fn instance_count(mut self, instance_count: u32) -> Self {
21445 self.0.instance_count = instance_count as _;
21446 self
21447 }
21448 #[inline]
21449 #[must_use]
21450 pub fn first_vertex(mut self, first_vertex: u32) -> Self {
21451 self.0.first_vertex = first_vertex as _;
21452 self
21453 }
21454 #[inline]
21455 #[must_use]
21456 pub fn first_instance(mut self, first_instance: u32) -> Self {
21457 self.0.first_instance = first_instance as _;
21458 self
21459 }
21460 #[inline]
21461 pub fn build(self) -> DrawIndirectCommand {
21462 self.0
21463 }
21464}
21465impl<'a> std::default::Default for DrawIndirectCommandBuilder<'a> {
21466 fn default() -> DrawIndirectCommandBuilder<'a> {
21467 Self::new()
21468 }
21469}
21470impl<'a> std::fmt::Debug for DrawIndirectCommandBuilder<'a> {
21471 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21472 std::fmt::Debug::fmt(&self.0, f)
21473 }
21474}
21475impl<'a> std::ops::Deref for DrawIndirectCommandBuilder<'a> {
21476 type Target = DrawIndirectCommand;
21477 fn deref(&self) -> &Self::Target {
21478 &self.0
21479 }
21480}
21481impl<'a> std::ops::DerefMut for DrawIndirectCommandBuilder<'a> {
21482 fn deref_mut(&mut self) -> &mut Self::Target {
21483 &mut self.0
21484 }
21485}
21486#[doc(alias = "VkDrawIndexedIndirectCommand")]
21488#[derive(Copy, Clone, Hash, PartialEq, Eq)]
21489#[repr(C)]
21490pub struct DrawIndexedIndirectCommand {
21491 pub index_count: u32,
21492 pub instance_count: u32,
21493 pub first_index: u32,
21494 pub vertex_offset: i32,
21495 pub first_instance: u32,
21496}
21497impl Default for DrawIndexedIndirectCommand {
21498 fn default() -> Self {
21499 Self {
21500 index_count: Default::default(),
21501 instance_count: Default::default(),
21502 first_index: Default::default(),
21503 vertex_offset: Default::default(),
21504 first_instance: Default::default(),
21505 }
21506 }
21507}
21508impl std::fmt::Debug for DrawIndexedIndirectCommand {
21509 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21510 f.debug_struct("DrawIndexedIndirectCommand")
21511 .field("index_count", &self.index_count)
21512 .field("instance_count", &self.instance_count)
21513 .field("first_index", &self.first_index)
21514 .field("vertex_offset", &self.vertex_offset)
21515 .field("first_instance", &self.first_instance)
21516 .finish()
21517 }
21518}
21519impl DrawIndexedIndirectCommand {
21520 #[inline]
21521 pub fn into_builder<'a>(self) -> DrawIndexedIndirectCommandBuilder<'a> {
21522 DrawIndexedIndirectCommandBuilder(self, std::marker::PhantomData)
21523 }
21524}
21525#[derive(Copy, Clone)]
21526#[repr(transparent)]
21528pub struct DrawIndexedIndirectCommandBuilder<'a>(
21529 DrawIndexedIndirectCommand,
21530 std::marker::PhantomData<&'a ()>,
21531);
21532impl<'a> DrawIndexedIndirectCommandBuilder<'a> {
21533 #[inline]
21534 pub fn new() -> DrawIndexedIndirectCommandBuilder<'a> {
21535 DrawIndexedIndirectCommandBuilder(Default::default(), std::marker::PhantomData)
21536 }
21537 #[inline]
21538 #[must_use]
21539 pub fn index_count(mut self, index_count: u32) -> Self {
21540 self.0.index_count = index_count as _;
21541 self
21542 }
21543 #[inline]
21544 #[must_use]
21545 pub fn instance_count(mut self, instance_count: u32) -> Self {
21546 self.0.instance_count = instance_count as _;
21547 self
21548 }
21549 #[inline]
21550 #[must_use]
21551 pub fn first_index(mut self, first_index: u32) -> Self {
21552 self.0.first_index = first_index as _;
21553 self
21554 }
21555 #[inline]
21556 #[must_use]
21557 pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
21558 self.0.vertex_offset = vertex_offset as _;
21559 self
21560 }
21561 #[inline]
21562 #[must_use]
21563 pub fn first_instance(mut self, first_instance: u32) -> Self {
21564 self.0.first_instance = first_instance as _;
21565 self
21566 }
21567 #[inline]
21568 pub fn build(self) -> DrawIndexedIndirectCommand {
21569 self.0
21570 }
21571}
21572impl<'a> std::default::Default for DrawIndexedIndirectCommandBuilder<'a> {
21573 fn default() -> DrawIndexedIndirectCommandBuilder<'a> {
21574 Self::new()
21575 }
21576}
21577impl<'a> std::fmt::Debug for DrawIndexedIndirectCommandBuilder<'a> {
21578 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21579 std::fmt::Debug::fmt(&self.0, f)
21580 }
21581}
21582impl<'a> std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> {
21583 type Target = DrawIndexedIndirectCommand;
21584 fn deref(&self) -> &Self::Target {
21585 &self.0
21586 }
21587}
21588impl<'a> std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> {
21589 fn deref_mut(&mut self) -> &mut Self::Target {
21590 &mut self.0
21591 }
21592}
21593#[doc(alias = "VkDispatchIndirectCommand")]
21595#[derive(Copy, Clone, Hash, PartialEq, Eq)]
21596#[repr(C)]
21597pub struct DispatchIndirectCommand {
21598 pub x: u32,
21599 pub y: u32,
21600 pub z: u32,
21601}
21602impl Default for DispatchIndirectCommand {
21603 fn default() -> Self {
21604 Self {
21605 x: Default::default(),
21606 y: Default::default(),
21607 z: Default::default(),
21608 }
21609 }
21610}
21611impl std::fmt::Debug for DispatchIndirectCommand {
21612 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21613 f.debug_struct("DispatchIndirectCommand")
21614 .field("x", &self.x)
21615 .field("y", &self.y)
21616 .field("z", &self.z)
21617 .finish()
21618 }
21619}
21620impl DispatchIndirectCommand {
21621 #[inline]
21622 pub fn into_builder<'a>(self) -> DispatchIndirectCommandBuilder<'a> {
21623 DispatchIndirectCommandBuilder(self, std::marker::PhantomData)
21624 }
21625}
21626#[derive(Copy, Clone)]
21627#[repr(transparent)]
21629pub struct DispatchIndirectCommandBuilder<'a>(
21630 DispatchIndirectCommand,
21631 std::marker::PhantomData<&'a ()>,
21632);
21633impl<'a> DispatchIndirectCommandBuilder<'a> {
21634 #[inline]
21635 pub fn new() -> DispatchIndirectCommandBuilder<'a> {
21636 DispatchIndirectCommandBuilder(Default::default(), std::marker::PhantomData)
21637 }
21638 #[inline]
21639 #[must_use]
21640 pub fn x(mut self, x: u32) -> Self {
21641 self.0.x = x as _;
21642 self
21643 }
21644 #[inline]
21645 #[must_use]
21646 pub fn y(mut self, y: u32) -> Self {
21647 self.0.y = y as _;
21648 self
21649 }
21650 #[inline]
21651 #[must_use]
21652 pub fn z(mut self, z: u32) -> Self {
21653 self.0.z = z as _;
21654 self
21655 }
21656 #[inline]
21657 pub fn build(self) -> DispatchIndirectCommand {
21658 self.0
21659 }
21660}
21661impl<'a> std::default::Default for DispatchIndirectCommandBuilder<'a> {
21662 fn default() -> DispatchIndirectCommandBuilder<'a> {
21663 Self::new()
21664 }
21665}
21666impl<'a> std::fmt::Debug for DispatchIndirectCommandBuilder<'a> {
21667 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21668 std::fmt::Debug::fmt(&self.0, f)
21669 }
21670}
21671impl<'a> std::ops::Deref for DispatchIndirectCommandBuilder<'a> {
21672 type Target = DispatchIndirectCommand;
21673 fn deref(&self) -> &Self::Target {
21674 &self.0
21675 }
21676}
21677impl<'a> std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> {
21678 fn deref_mut(&mut self) -> &mut Self::Target {
21679 &mut self.0
21680 }
21681}
21682#[doc(alias = "VkSubmitInfo")]
21684#[derive(Copy, Clone)]
21685#[repr(C)]
21686pub struct SubmitInfo {
21687 pub s_type: crate::vk1_0::StructureType,
21688 pub p_next: *const std::ffi::c_void,
21689 pub wait_semaphore_count: u32,
21690 pub p_wait_semaphores: *const crate::vk1_0::Semaphore,
21691 pub p_wait_dst_stage_mask: *const crate::vk1_0::PipelineStageFlags,
21692 pub command_buffer_count: u32,
21693 pub p_command_buffers: *const crate::vk1_0::CommandBuffer,
21694 pub signal_semaphore_count: u32,
21695 pub p_signal_semaphores: *const crate::vk1_0::Semaphore,
21696}
21697impl SubmitInfo {
21698 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::SUBMIT_INFO;
21699}
21700impl Default for SubmitInfo {
21701 fn default() -> Self {
21702 Self {
21703 s_type: Self::STRUCTURE_TYPE,
21704 p_next: std::ptr::null(),
21705 wait_semaphore_count: Default::default(),
21706 p_wait_semaphores: std::ptr::null(),
21707 p_wait_dst_stage_mask: std::ptr::null(),
21708 command_buffer_count: Default::default(),
21709 p_command_buffers: std::ptr::null(),
21710 signal_semaphore_count: Default::default(),
21711 p_signal_semaphores: std::ptr::null(),
21712 }
21713 }
21714}
21715impl std::fmt::Debug for SubmitInfo {
21716 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21717 f.debug_struct("SubmitInfo")
21718 .field("s_type", &self.s_type)
21719 .field("p_next", &self.p_next)
21720 .field("wait_semaphore_count", &self.wait_semaphore_count)
21721 .field("p_wait_semaphores", &self.p_wait_semaphores)
21722 .field("p_wait_dst_stage_mask", &self.p_wait_dst_stage_mask)
21723 .field("command_buffer_count", &self.command_buffer_count)
21724 .field("p_command_buffers", &self.p_command_buffers)
21725 .field("signal_semaphore_count", &self.signal_semaphore_count)
21726 .field("p_signal_semaphores", &self.p_signal_semaphores)
21727 .finish()
21728 }
21729}
21730impl SubmitInfo {
21731 #[inline]
21732 pub fn into_builder<'a>(self) -> SubmitInfoBuilder<'a> {
21733 SubmitInfoBuilder(self, std::marker::PhantomData)
21734 }
21735}
21736#[derive(Copy, Clone)]
21737#[repr(transparent)]
21739pub struct SubmitInfoBuilder<'a>(SubmitInfo, std::marker::PhantomData<&'a ()>);
21740impl<'a> SubmitInfoBuilder<'a> {
21741 #[inline]
21742 pub fn new() -> SubmitInfoBuilder<'a> {
21743 SubmitInfoBuilder(Default::default(), std::marker::PhantomData)
21744 }
21745 #[inline]
21746 #[must_use]
21747 pub fn wait_semaphores(
21748 mut self,
21749 wait_semaphores: &'a [crate::vk1_0::Semaphore],
21750 ) -> Self {
21751 self.0.p_wait_semaphores = wait_semaphores.as_ptr() as _;
21752 self.0.wait_semaphore_count = wait_semaphores.len() as _;
21753 self
21754 }
21755 #[inline]
21756 #[must_use]
21757 pub fn wait_dst_stage_mask(
21758 mut self,
21759 wait_dst_stage_mask: &'a [crate::vk1_0::PipelineStageFlags],
21760 ) -> Self {
21761 self.0.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr() as _;
21762 self.0.wait_semaphore_count = wait_dst_stage_mask.len() as _;
21763 self
21764 }
21765 #[inline]
21766 #[must_use]
21767 pub fn command_buffers(
21768 mut self,
21769 command_buffers: &'a [crate::vk1_0::CommandBuffer],
21770 ) -> Self {
21771 self.0.p_command_buffers = command_buffers.as_ptr() as _;
21772 self.0.command_buffer_count = command_buffers.len() as _;
21773 self
21774 }
21775 #[inline]
21776 #[must_use]
21777 pub fn signal_semaphores(
21778 mut self,
21779 signal_semaphores: &'a [crate::vk1_0::Semaphore],
21780 ) -> Self {
21781 self.0.p_signal_semaphores = signal_semaphores.as_ptr() as _;
21782 self.0.signal_semaphore_count = signal_semaphores.len() as _;
21783 self
21784 }
21785 #[inline]
21786 pub fn build_dangling(self) -> SubmitInfo {
21789 self.0
21790 }
21791}
21792impl<'a> std::default::Default for SubmitInfoBuilder<'a> {
21793 fn default() -> SubmitInfoBuilder<'a> {
21794 Self::new()
21795 }
21796}
21797impl<'a> std::fmt::Debug for SubmitInfoBuilder<'a> {
21798 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
21799 std::fmt::Debug::fmt(&self.0, f)
21800 }
21801}
21802impl<'a> std::ops::Deref for SubmitInfoBuilder<'a> {
21803 type Target = SubmitInfo;
21804 fn deref(&self) -> &Self::Target {
21805 &self.0
21806 }
21807}
21808impl<'a> std::ops::DerefMut for SubmitInfoBuilder<'a> {
21809 fn deref_mut(&mut self) -> &mut Self::Target {
21810 &mut self.0
21811 }
21812}
21813#[doc(alias = "VK_MAKE_VERSION")]
21815#[deprecated = "VK_MAKE_API_VERSION should be used instead."]
21816pub const fn make_version(major: u32, minor: u32, patch: u32) -> u32 {
21817 (major << 22) | (minor << 12) | patch
21818}
21819#[doc(alias = "VK_VERSION_MAJOR")]
21821#[deprecated = "VK_API_VERSION_MAJOR should be used instead."]
21822pub const fn version_major(version: u32) -> u32 {
21823 version >> 22
21824}
21825#[doc(alias = "VK_VERSION_MINOR")]
21827#[deprecated = "VK_API_VERSION_MINOR should be used instead."]
21828pub const fn version_minor(version: u32) -> u32 {
21829 (version >> 12) & 0x3ff
21830}
21831#[doc(alias = "VK_VERSION_PATCH")]
21833#[deprecated = "VK_API_VERSION_PATCH should be used instead."]
21834pub const fn version_patch(version: u32) -> u32 {
21835 version & 0xfff
21836}
21837#[doc(alias = "VK_MAKE_API_VERSION")]
21839pub const fn make_api_version(variant: u32, major: u32, minor: u32, patch: u32) -> u32 {
21840 (variant << 29) | (major << 22) | (minor << 12) | patch
21841}
21842#[doc(alias = "VK_API_VERSION_VARIANT")]
21844pub const fn api_version_variant(version: u32) -> u32 {
21845 version >> 29
21846}
21847#[doc(alias = "VK_API_VERSION_MAJOR")]
21849pub const fn api_version_major(version: u32) -> u32 {
21850 (version >> 22) & 0x7f
21851}
21852#[doc(alias = "VK_API_VERSION_MINOR")]
21854pub const fn api_version_minor(version: u32) -> u32 {
21855 (version >> 12) & 0x3ff
21856}
21857#[doc(alias = "VK_API_VERSION_PATCH")]
21859pub const fn api_version_patch(version: u32) -> u32 {
21860 version & 0xfff
21861}
21862#[doc(alias = "VK_API_VERSION_1_0")]
21864pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0);
21865#[doc(alias = "VK_API_VERSION_1_1")]
21867pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0);
21868#[doc(alias = "VK_API_VERSION_1_2")]
21870pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0);
21871#[doc(alias = "VK_API_VERSION_1_3")]
21873pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0);
21874#[doc(alias = "VK_HEADER_VERSION")]
21876pub const HEADER_VERSION: u32 = 213u32;
21877#[doc(alias = "VK_HEADER_VERSION_COMPLETE")]
21879pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1u32, 3u32, 213u32);
21880impl<T> crate::CustomEntryLoader<T> {
21882 #[inline]
21883 #[track_caller]
21884 #[doc(alias = "vkCreateInstance")]
21886 pub unsafe fn create_instance(
21887 &self,
21888 create_info: &crate::vk1_0::InstanceCreateInfo,
21889 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
21890 ) -> crate::utils::VulkanResult<crate::vk1_0::Instance> {
21891 let _function = self.create_instance.expect(crate::NOT_LOADED_MESSAGE);
21892 let mut instance = Default::default();
21893 let _return = _function(
21894 create_info as _,
21895 match allocator {
21896 Some(v) => v,
21897 None => std::ptr::null(),
21898 },
21899 &mut instance,
21900 );
21901 crate::utils::VulkanResult::new(_return, instance)
21902 }
21903 #[inline]
21904 #[track_caller]
21905 #[doc(alias = "vkEnumerateInstanceLayerProperties")]
21907 pub unsafe fn enumerate_instance_layer_properties(
21908 &self,
21909 property_count: Option<u32>,
21910 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::LayerProperties>> {
21911 let _function = self
21912 .enumerate_instance_layer_properties
21913 .expect(crate::NOT_LOADED_MESSAGE);
21914 let mut property_count = match property_count {
21915 Some(v) => v,
21916 None => {
21917 let mut v = Default::default();
21918 _function(&mut v, std::ptr::null_mut());
21919 v
21920 }
21921 };
21922 let mut properties = crate::SmallVec::from_elem(
21923 Default::default(),
21924 property_count as _,
21925 );
21926 let _return = _function(&mut property_count, properties.as_mut_ptr());
21927 crate::utils::VulkanResult::new(_return, properties)
21928 }
21929 #[inline]
21930 #[track_caller]
21931 #[doc(alias = "vkEnumerateInstanceExtensionProperties")]
21933 pub unsafe fn enumerate_instance_extension_properties(
21934 &self,
21935 layer_name: Option<&std::ffi::CStr>,
21936 property_count: Option<u32>,
21937 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::ExtensionProperties>> {
21938 let _function = self
21939 .enumerate_instance_extension_properties
21940 .expect(crate::NOT_LOADED_MESSAGE);
21941 let mut property_count = match property_count {
21942 Some(v) => v,
21943 None => {
21944 let mut v = Default::default();
21945 _function(
21946 match layer_name {
21947 Some(v) => v.as_ptr(),
21948 None => std::ptr::null(),
21949 },
21950 &mut v,
21951 std::ptr::null_mut(),
21952 );
21953 v
21954 }
21955 };
21956 let mut properties = crate::SmallVec::from_elem(
21957 Default::default(),
21958 property_count as _,
21959 );
21960 let _return = _function(
21961 match layer_name {
21962 Some(v) => v.as_ptr(),
21963 None => std::ptr::null(),
21964 },
21965 &mut property_count,
21966 properties.as_mut_ptr(),
21967 );
21968 crate::utils::VulkanResult::new(_return, properties)
21969 }
21970}
21971impl crate::InstanceLoader {
21973 #[inline]
21974 #[track_caller]
21975 #[doc(alias = "vkDestroyInstance")]
21977 pub unsafe fn destroy_instance(
21978 &self,
21979 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
21980 ) -> () {
21981 let _function = self.destroy_instance.expect(crate::NOT_LOADED_MESSAGE);
21982 let _return = _function(
21983 self.handle,
21984 match allocator {
21985 Some(v) => v,
21986 None => std::ptr::null(),
21987 },
21988 );
21989 ()
21990 }
21991 #[inline]
21992 #[track_caller]
21993 #[doc(alias = "vkEnumeratePhysicalDevices")]
21995 pub unsafe fn enumerate_physical_devices(
21996 &self,
21997 physical_device_count: Option<u32>,
21998 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::PhysicalDevice>> {
21999 let _function = self
22000 .enumerate_physical_devices
22001 .expect(crate::NOT_LOADED_MESSAGE);
22002 let mut physical_device_count = match physical_device_count {
22003 Some(v) => v,
22004 None => {
22005 let mut v = Default::default();
22006 _function(self.handle, &mut v, std::ptr::null_mut());
22007 v
22008 }
22009 };
22010 let mut physical_devices = crate::SmallVec::from_elem(
22011 Default::default(),
22012 physical_device_count as _,
22013 );
22014 let _return = _function(
22015 self.handle,
22016 &mut physical_device_count,
22017 physical_devices.as_mut_ptr(),
22018 );
22019 crate::utils::VulkanResult::new(_return, physical_devices)
22020 }
22021 #[inline]
22022 #[track_caller]
22023 #[doc(alias = "vkGetInstanceProcAddr")]
22025 pub unsafe fn get_instance_proc_addr(
22026 &self,
22027 name: Option<&std::ffi::CStr>,
22028 ) -> Option<crate::vk1_0::PFN_vkVoidFunction> {
22029 let _function = self.get_instance_proc_addr.expect(crate::NOT_LOADED_MESSAGE);
22030 let _return = _function(
22031 self.handle,
22032 match name {
22033 Some(v) => v.as_ptr(),
22034 None => std::ptr::null(),
22035 },
22036 );
22037 _return
22038 }
22039 #[inline]
22040 #[track_caller]
22041 #[doc(alias = "vkGetPhysicalDeviceProperties")]
22043 pub unsafe fn get_physical_device_properties(
22044 &self,
22045 physical_device: crate::vk1_0::PhysicalDevice,
22046 ) -> crate::vk1_0::PhysicalDeviceProperties {
22047 let _function = self
22048 .get_physical_device_properties
22049 .expect(crate::NOT_LOADED_MESSAGE);
22050 let mut properties = Default::default();
22051 let _return = _function(physical_device as _, &mut properties);
22052 properties
22053 }
22054 #[inline]
22055 #[track_caller]
22056 #[doc(alias = "vkGetPhysicalDeviceQueueFamilyProperties")]
22058 pub unsafe fn get_physical_device_queue_family_properties(
22059 &self,
22060 physical_device: crate::vk1_0::PhysicalDevice,
22061 queue_family_property_count: Option<u32>,
22062 ) -> crate::SmallVec<crate::vk1_0::QueueFamilyProperties> {
22063 let _function = self
22064 .get_physical_device_queue_family_properties
22065 .expect(crate::NOT_LOADED_MESSAGE);
22066 let mut queue_family_property_count = match queue_family_property_count {
22067 Some(v) => v,
22068 None => {
22069 let mut v = Default::default();
22070 _function(physical_device as _, &mut v, std::ptr::null_mut());
22071 v
22072 }
22073 };
22074 let mut queue_family_properties = crate::SmallVec::from_elem(
22075 Default::default(),
22076 queue_family_property_count as _,
22077 );
22078 let _return = _function(
22079 physical_device as _,
22080 &mut queue_family_property_count,
22081 queue_family_properties.as_mut_ptr(),
22082 );
22083 queue_family_properties
22084 }
22085 #[inline]
22086 #[track_caller]
22087 #[doc(alias = "vkGetPhysicalDeviceMemoryProperties")]
22089 pub unsafe fn get_physical_device_memory_properties(
22090 &self,
22091 physical_device: crate::vk1_0::PhysicalDevice,
22092 ) -> crate::vk1_0::PhysicalDeviceMemoryProperties {
22093 let _function = self
22094 .get_physical_device_memory_properties
22095 .expect(crate::NOT_LOADED_MESSAGE);
22096 let mut memory_properties = Default::default();
22097 let _return = _function(physical_device as _, &mut memory_properties);
22098 memory_properties
22099 }
22100 #[inline]
22101 #[track_caller]
22102 #[doc(alias = "vkGetPhysicalDeviceFeatures")]
22104 pub unsafe fn get_physical_device_features(
22105 &self,
22106 physical_device: crate::vk1_0::PhysicalDevice,
22107 ) -> crate::vk1_0::PhysicalDeviceFeatures {
22108 let _function = self
22109 .get_physical_device_features
22110 .expect(crate::NOT_LOADED_MESSAGE);
22111 let mut features = Default::default();
22112 let _return = _function(physical_device as _, &mut features);
22113 features
22114 }
22115 #[inline]
22116 #[track_caller]
22117 #[doc(alias = "vkGetPhysicalDeviceFormatProperties")]
22119 pub unsafe fn get_physical_device_format_properties(
22120 &self,
22121 physical_device: crate::vk1_0::PhysicalDevice,
22122 format: crate::vk1_0::Format,
22123 ) -> crate::vk1_0::FormatProperties {
22124 let _function = self
22125 .get_physical_device_format_properties
22126 .expect(crate::NOT_LOADED_MESSAGE);
22127 let mut format_properties = Default::default();
22128 let _return = _function(
22129 physical_device as _,
22130 format as _,
22131 &mut format_properties,
22132 );
22133 format_properties
22134 }
22135 #[inline]
22136 #[track_caller]
22137 #[doc(alias = "vkGetPhysicalDeviceImageFormatProperties")]
22139 pub unsafe fn get_physical_device_image_format_properties(
22140 &self,
22141 physical_device: crate::vk1_0::PhysicalDevice,
22142 format: crate::vk1_0::Format,
22143 _type: crate::vk1_0::ImageType,
22144 tiling: crate::vk1_0::ImageTiling,
22145 usage: crate::vk1_0::ImageUsageFlags,
22146 flags: crate::vk1_0::ImageCreateFlags,
22147 ) -> crate::utils::VulkanResult<crate::vk1_0::ImageFormatProperties> {
22148 let _function = self
22149 .get_physical_device_image_format_properties
22150 .expect(crate::NOT_LOADED_MESSAGE);
22151 let mut image_format_properties = Default::default();
22152 let _return = _function(
22153 physical_device as _,
22154 format as _,
22155 _type as _,
22156 tiling as _,
22157 usage as _,
22158 flags as _,
22159 &mut image_format_properties,
22160 );
22161 crate::utils::VulkanResult::new(_return, image_format_properties)
22162 }
22163 #[inline]
22164 #[track_caller]
22165 #[doc(alias = "vkCreateDevice")]
22167 pub unsafe fn create_device(
22168 &self,
22169 physical_device: crate::vk1_0::PhysicalDevice,
22170 create_info: &crate::vk1_0::DeviceCreateInfo,
22171 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22172 ) -> crate::utils::VulkanResult<crate::vk1_0::Device> {
22173 let _function = self.create_device.expect(crate::NOT_LOADED_MESSAGE);
22174 let mut device = Default::default();
22175 let _return = _function(
22176 physical_device as _,
22177 create_info as _,
22178 match allocator {
22179 Some(v) => v,
22180 None => std::ptr::null(),
22181 },
22182 &mut device,
22183 );
22184 crate::utils::VulkanResult::new(_return, device)
22185 }
22186 #[inline]
22187 #[track_caller]
22188 #[doc(alias = "vkEnumerateDeviceLayerProperties")]
22190 pub unsafe fn enumerate_device_layer_properties(
22191 &self,
22192 physical_device: crate::vk1_0::PhysicalDevice,
22193 property_count: Option<u32>,
22194 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::LayerProperties>> {
22195 let _function = self
22196 .enumerate_device_layer_properties
22197 .expect(crate::NOT_LOADED_MESSAGE);
22198 let mut property_count = match property_count {
22199 Some(v) => v,
22200 None => {
22201 let mut v = Default::default();
22202 _function(physical_device as _, &mut v, std::ptr::null_mut());
22203 v
22204 }
22205 };
22206 let mut properties = crate::SmallVec::from_elem(
22207 Default::default(),
22208 property_count as _,
22209 );
22210 let _return = _function(
22211 physical_device as _,
22212 &mut property_count,
22213 properties.as_mut_ptr(),
22214 );
22215 crate::utils::VulkanResult::new(_return, properties)
22216 }
22217 #[inline]
22218 #[track_caller]
22219 #[doc(alias = "vkEnumerateDeviceExtensionProperties")]
22221 pub unsafe fn enumerate_device_extension_properties(
22222 &self,
22223 physical_device: crate::vk1_0::PhysicalDevice,
22224 layer_name: Option<&std::ffi::CStr>,
22225 property_count: Option<u32>,
22226 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::ExtensionProperties>> {
22227 let _function = self
22228 .enumerate_device_extension_properties
22229 .expect(crate::NOT_LOADED_MESSAGE);
22230 let mut property_count = match property_count {
22231 Some(v) => v,
22232 None => {
22233 let mut v = Default::default();
22234 _function(
22235 physical_device as _,
22236 match layer_name {
22237 Some(v) => v.as_ptr(),
22238 None => std::ptr::null(),
22239 },
22240 &mut v,
22241 std::ptr::null_mut(),
22242 );
22243 v
22244 }
22245 };
22246 let mut properties = crate::SmallVec::from_elem(
22247 Default::default(),
22248 property_count as _,
22249 );
22250 let _return = _function(
22251 physical_device as _,
22252 match layer_name {
22253 Some(v) => v.as_ptr(),
22254 None => std::ptr::null(),
22255 },
22256 &mut property_count,
22257 properties.as_mut_ptr(),
22258 );
22259 crate::utils::VulkanResult::new(_return, properties)
22260 }
22261 #[inline]
22262 #[track_caller]
22263 #[doc(alias = "vkGetPhysicalDeviceSparseImageFormatProperties")]
22265 pub unsafe fn get_physical_device_sparse_image_format_properties(
22266 &self,
22267 physical_device: crate::vk1_0::PhysicalDevice,
22268 format: crate::vk1_0::Format,
22269 _type: crate::vk1_0::ImageType,
22270 samples: crate::vk1_0::SampleCountFlagBits,
22271 usage: crate::vk1_0::ImageUsageFlags,
22272 tiling: crate::vk1_0::ImageTiling,
22273 property_count: Option<u32>,
22274 ) -> crate::SmallVec<crate::vk1_0::SparseImageFormatProperties> {
22275 let _function = self
22276 .get_physical_device_sparse_image_format_properties
22277 .expect(crate::NOT_LOADED_MESSAGE);
22278 let mut property_count = match property_count {
22279 Some(v) => v,
22280 None => {
22281 let mut v = Default::default();
22282 _function(
22283 physical_device as _,
22284 format as _,
22285 _type as _,
22286 samples as _,
22287 usage as _,
22288 tiling as _,
22289 &mut v,
22290 std::ptr::null_mut(),
22291 );
22292 v
22293 }
22294 };
22295 let mut properties = crate::SmallVec::from_elem(
22296 Default::default(),
22297 property_count as _,
22298 );
22299 let _return = _function(
22300 physical_device as _,
22301 format as _,
22302 _type as _,
22303 samples as _,
22304 usage as _,
22305 tiling as _,
22306 &mut property_count,
22307 properties.as_mut_ptr(),
22308 );
22309 properties
22310 }
22311}
22312impl crate::DeviceLoader {
22314 #[inline]
22315 #[track_caller]
22316 #[doc(alias = "vkGetDeviceProcAddr")]
22318 pub unsafe fn get_device_proc_addr(
22319 &self,
22320 name: Option<&std::ffi::CStr>,
22321 ) -> Option<crate::vk1_0::PFN_vkVoidFunction> {
22322 let _function = self.get_device_proc_addr.expect(crate::NOT_LOADED_MESSAGE);
22323 let _return = _function(
22324 self.handle,
22325 match name {
22326 Some(v) => v.as_ptr(),
22327 None => std::ptr::null(),
22328 },
22329 );
22330 _return
22331 }
22332 #[inline]
22333 #[track_caller]
22334 #[doc(alias = "vkDestroyDevice")]
22336 pub unsafe fn destroy_device(
22337 &self,
22338 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22339 ) -> () {
22340 let _function = self.destroy_device.expect(crate::NOT_LOADED_MESSAGE);
22341 let _return = _function(
22342 self.handle,
22343 match allocator {
22344 Some(v) => v,
22345 None => std::ptr::null(),
22346 },
22347 );
22348 ()
22349 }
22350 #[inline]
22351 #[track_caller]
22352 #[doc(alias = "vkGetDeviceQueue")]
22354 pub unsafe fn get_device_queue(
22355 &self,
22356 queue_family_index: u32,
22357 queue_index: u32,
22358 ) -> crate::vk1_0::Queue {
22359 let _function = self.get_device_queue.expect(crate::NOT_LOADED_MESSAGE);
22360 let mut queue = Default::default();
22361 let _return = _function(
22362 self.handle,
22363 queue_family_index as _,
22364 queue_index as _,
22365 &mut queue,
22366 );
22367 queue
22368 }
22369 #[inline]
22370 #[track_caller]
22371 #[doc(alias = "vkQueueSubmit")]
22373 pub unsafe fn queue_submit(
22374 &self,
22375 queue: crate::vk1_0::Queue,
22376 submits: &[crate::vk1_0::SubmitInfoBuilder],
22377 fence: crate::vk1_0::Fence,
22378 ) -> crate::utils::VulkanResult<()> {
22379 let _function = self.queue_submit.expect(crate::NOT_LOADED_MESSAGE);
22380 let submit_count = submits.len();
22381 let _return = _function(
22382 queue as _,
22383 submit_count as _,
22384 submits.as_ptr() as _,
22385 fence as _,
22386 );
22387 crate::utils::VulkanResult::new(_return, ())
22388 }
22389 #[inline]
22390 #[track_caller]
22391 #[doc(alias = "vkQueueWaitIdle")]
22393 pub unsafe fn queue_wait_idle(
22394 &self,
22395 queue: crate::vk1_0::Queue,
22396 ) -> crate::utils::VulkanResult<()> {
22397 let _function = self.queue_wait_idle.expect(crate::NOT_LOADED_MESSAGE);
22398 let _return = _function(queue as _);
22399 crate::utils::VulkanResult::new(_return, ())
22400 }
22401 #[inline]
22402 #[track_caller]
22403 #[doc(alias = "vkDeviceWaitIdle")]
22405 pub unsafe fn device_wait_idle(&self) -> crate::utils::VulkanResult<()> {
22406 let _function = self.device_wait_idle.expect(crate::NOT_LOADED_MESSAGE);
22407 let _return = _function(self.handle);
22408 crate::utils::VulkanResult::new(_return, ())
22409 }
22410 #[inline]
22411 #[track_caller]
22412 #[doc(alias = "vkAllocateMemory")]
22414 pub unsafe fn allocate_memory(
22415 &self,
22416 allocate_info: &crate::vk1_0::MemoryAllocateInfo,
22417 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22418 ) -> crate::utils::VulkanResult<crate::vk1_0::DeviceMemory> {
22419 let _function = self.allocate_memory.expect(crate::NOT_LOADED_MESSAGE);
22420 let mut memory = Default::default();
22421 let _return = _function(
22422 self.handle,
22423 allocate_info as _,
22424 match allocator {
22425 Some(v) => v,
22426 None => std::ptr::null(),
22427 },
22428 &mut memory,
22429 );
22430 crate::utils::VulkanResult::new(_return, memory)
22431 }
22432 #[inline]
22433 #[track_caller]
22434 #[doc(alias = "vkFreeMemory")]
22436 pub unsafe fn free_memory(
22437 &self,
22438 memory: crate::vk1_0::DeviceMemory,
22439 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22440 ) -> () {
22441 let _function = self.free_memory.expect(crate::NOT_LOADED_MESSAGE);
22442 let _return = _function(
22443 self.handle,
22444 memory as _,
22445 match allocator {
22446 Some(v) => v,
22447 None => std::ptr::null(),
22448 },
22449 );
22450 ()
22451 }
22452 #[inline]
22453 #[track_caller]
22454 #[doc(alias = "vkMapMemory")]
22456 pub unsafe fn map_memory(
22457 &self,
22458 memory: crate::vk1_0::DeviceMemory,
22459 offset: crate::vk1_0::DeviceSize,
22460 size: crate::vk1_0::DeviceSize,
22461 flags: crate::vk1_0::MemoryMapFlags,
22462 ) -> crate::utils::VulkanResult<*mut std::ffi::c_void> {
22463 let _function = self.map_memory.expect(crate::NOT_LOADED_MESSAGE);
22464 let mut data = std::ptr::null_mut();
22465 let _return = _function(
22466 self.handle,
22467 memory as _,
22468 offset as _,
22469 size as _,
22470 flags as _,
22471 &mut data,
22472 );
22473 crate::utils::VulkanResult::new(_return, data)
22474 }
22475 #[inline]
22476 #[track_caller]
22477 #[doc(alias = "vkUnmapMemory")]
22479 pub unsafe fn unmap_memory(&self, memory: crate::vk1_0::DeviceMemory) -> () {
22480 let _function = self.unmap_memory.expect(crate::NOT_LOADED_MESSAGE);
22481 let _return = _function(self.handle, memory as _);
22482 ()
22483 }
22484 #[inline]
22485 #[track_caller]
22486 #[doc(alias = "vkFlushMappedMemoryRanges")]
22488 pub unsafe fn flush_mapped_memory_ranges(
22489 &self,
22490 memory_ranges: &[crate::vk1_0::MappedMemoryRangeBuilder],
22491 ) -> crate::utils::VulkanResult<()> {
22492 let _function = self
22493 .flush_mapped_memory_ranges
22494 .expect(crate::NOT_LOADED_MESSAGE);
22495 let memory_range_count = memory_ranges.len();
22496 let _return = _function(
22497 self.handle,
22498 memory_range_count as _,
22499 memory_ranges.as_ptr() as _,
22500 );
22501 crate::utils::VulkanResult::new(_return, ())
22502 }
22503 #[inline]
22504 #[track_caller]
22505 #[doc(alias = "vkInvalidateMappedMemoryRanges")]
22507 pub unsafe fn invalidate_mapped_memory_ranges(
22508 &self,
22509 memory_ranges: &[crate::vk1_0::MappedMemoryRangeBuilder],
22510 ) -> crate::utils::VulkanResult<()> {
22511 let _function = self
22512 .invalidate_mapped_memory_ranges
22513 .expect(crate::NOT_LOADED_MESSAGE);
22514 let memory_range_count = memory_ranges.len();
22515 let _return = _function(
22516 self.handle,
22517 memory_range_count as _,
22518 memory_ranges.as_ptr() as _,
22519 );
22520 crate::utils::VulkanResult::new(_return, ())
22521 }
22522 #[inline]
22523 #[track_caller]
22524 #[doc(alias = "vkGetDeviceMemoryCommitment")]
22526 pub unsafe fn get_device_memory_commitment(
22527 &self,
22528 memory: crate::vk1_0::DeviceMemory,
22529 ) -> crate::vk1_0::DeviceSize {
22530 let _function = self
22531 .get_device_memory_commitment
22532 .expect(crate::NOT_LOADED_MESSAGE);
22533 let mut committed_memory_in_bytes = Default::default();
22534 let _return = _function(
22535 self.handle,
22536 memory as _,
22537 &mut committed_memory_in_bytes,
22538 );
22539 committed_memory_in_bytes
22540 }
22541 #[inline]
22542 #[track_caller]
22543 #[doc(alias = "vkGetBufferMemoryRequirements")]
22545 pub unsafe fn get_buffer_memory_requirements(
22546 &self,
22547 buffer: crate::vk1_0::Buffer,
22548 ) -> crate::vk1_0::MemoryRequirements {
22549 let _function = self
22550 .get_buffer_memory_requirements
22551 .expect(crate::NOT_LOADED_MESSAGE);
22552 let mut memory_requirements = Default::default();
22553 let _return = _function(self.handle, buffer as _, &mut memory_requirements);
22554 memory_requirements
22555 }
22556 #[inline]
22557 #[track_caller]
22558 #[doc(alias = "vkBindBufferMemory")]
22560 pub unsafe fn bind_buffer_memory(
22561 &self,
22562 buffer: crate::vk1_0::Buffer,
22563 memory: crate::vk1_0::DeviceMemory,
22564 memory_offset: crate::vk1_0::DeviceSize,
22565 ) -> crate::utils::VulkanResult<()> {
22566 let _function = self.bind_buffer_memory.expect(crate::NOT_LOADED_MESSAGE);
22567 let _return = _function(
22568 self.handle,
22569 buffer as _,
22570 memory as _,
22571 memory_offset as _,
22572 );
22573 crate::utils::VulkanResult::new(_return, ())
22574 }
22575 #[inline]
22576 #[track_caller]
22577 #[doc(alias = "vkGetImageMemoryRequirements")]
22579 pub unsafe fn get_image_memory_requirements(
22580 &self,
22581 image: crate::vk1_0::Image,
22582 ) -> crate::vk1_0::MemoryRequirements {
22583 let _function = self
22584 .get_image_memory_requirements
22585 .expect(crate::NOT_LOADED_MESSAGE);
22586 let mut memory_requirements = Default::default();
22587 let _return = _function(self.handle, image as _, &mut memory_requirements);
22588 memory_requirements
22589 }
22590 #[inline]
22591 #[track_caller]
22592 #[doc(alias = "vkBindImageMemory")]
22594 pub unsafe fn bind_image_memory(
22595 &self,
22596 image: crate::vk1_0::Image,
22597 memory: crate::vk1_0::DeviceMemory,
22598 memory_offset: crate::vk1_0::DeviceSize,
22599 ) -> crate::utils::VulkanResult<()> {
22600 let _function = self.bind_image_memory.expect(crate::NOT_LOADED_MESSAGE);
22601 let _return = _function(
22602 self.handle,
22603 image as _,
22604 memory as _,
22605 memory_offset as _,
22606 );
22607 crate::utils::VulkanResult::new(_return, ())
22608 }
22609 #[inline]
22610 #[track_caller]
22611 #[doc(alias = "vkGetImageSparseMemoryRequirements")]
22613 pub unsafe fn get_image_sparse_memory_requirements(
22614 &self,
22615 image: crate::vk1_0::Image,
22616 sparse_memory_requirement_count: Option<u32>,
22617 ) -> crate::SmallVec<crate::vk1_0::SparseImageMemoryRequirements> {
22618 let _function = self
22619 .get_image_sparse_memory_requirements
22620 .expect(crate::NOT_LOADED_MESSAGE);
22621 let mut sparse_memory_requirement_count = match sparse_memory_requirement_count {
22622 Some(v) => v,
22623 None => {
22624 let mut v = Default::default();
22625 _function(self.handle, image as _, &mut v, std::ptr::null_mut());
22626 v
22627 }
22628 };
22629 let mut sparse_memory_requirements = crate::SmallVec::from_elem(
22630 Default::default(),
22631 sparse_memory_requirement_count as _,
22632 );
22633 let _return = _function(
22634 self.handle,
22635 image as _,
22636 &mut sparse_memory_requirement_count,
22637 sparse_memory_requirements.as_mut_ptr(),
22638 );
22639 sparse_memory_requirements
22640 }
22641 #[inline]
22642 #[track_caller]
22643 #[doc(alias = "vkQueueBindSparse")]
22645 pub unsafe fn queue_bind_sparse(
22646 &self,
22647 queue: crate::vk1_0::Queue,
22648 bind_info: &[crate::vk1_0::BindSparseInfoBuilder],
22649 fence: crate::vk1_0::Fence,
22650 ) -> crate::utils::VulkanResult<()> {
22651 let _function = self.queue_bind_sparse.expect(crate::NOT_LOADED_MESSAGE);
22652 let bind_info_count = bind_info.len();
22653 let _return = _function(
22654 queue as _,
22655 bind_info_count as _,
22656 bind_info.as_ptr() as _,
22657 fence as _,
22658 );
22659 crate::utils::VulkanResult::new(_return, ())
22660 }
22661 #[inline]
22662 #[track_caller]
22663 #[doc(alias = "vkCreateFence")]
22665 pub unsafe fn create_fence(
22666 &self,
22667 create_info: &crate::vk1_0::FenceCreateInfo,
22668 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22669 ) -> crate::utils::VulkanResult<crate::vk1_0::Fence> {
22670 let _function = self.create_fence.expect(crate::NOT_LOADED_MESSAGE);
22671 let mut fence = Default::default();
22672 let _return = _function(
22673 self.handle,
22674 create_info as _,
22675 match allocator {
22676 Some(v) => v,
22677 None => std::ptr::null(),
22678 },
22679 &mut fence,
22680 );
22681 crate::utils::VulkanResult::new(_return, fence)
22682 }
22683 #[inline]
22684 #[track_caller]
22685 #[doc(alias = "vkDestroyFence")]
22687 pub unsafe fn destroy_fence(
22688 &self,
22689 fence: crate::vk1_0::Fence,
22690 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22691 ) -> () {
22692 let _function = self.destroy_fence.expect(crate::NOT_LOADED_MESSAGE);
22693 let _return = _function(
22694 self.handle,
22695 fence as _,
22696 match allocator {
22697 Some(v) => v,
22698 None => std::ptr::null(),
22699 },
22700 );
22701 ()
22702 }
22703 #[inline]
22704 #[track_caller]
22705 #[doc(alias = "vkResetFences")]
22707 pub unsafe fn reset_fences(
22708 &self,
22709 fences: &[crate::vk1_0::Fence],
22710 ) -> crate::utils::VulkanResult<()> {
22711 let _function = self.reset_fences.expect(crate::NOT_LOADED_MESSAGE);
22712 let fence_count = fences.len();
22713 let _return = _function(self.handle, fence_count as _, fences.as_ptr() as _);
22714 crate::utils::VulkanResult::new(_return, ())
22715 }
22716 #[inline]
22717 #[track_caller]
22718 #[doc(alias = "vkGetFenceStatus")]
22720 pub unsafe fn get_fence_status(
22721 &self,
22722 fence: crate::vk1_0::Fence,
22723 ) -> crate::utils::VulkanResult<()> {
22724 let _function = self.get_fence_status.expect(crate::NOT_LOADED_MESSAGE);
22725 let _return = _function(self.handle, fence as _);
22726 crate::utils::VulkanResult::new(_return, ())
22727 }
22728 #[inline]
22729 #[track_caller]
22730 #[doc(alias = "vkWaitForFences")]
22732 pub unsafe fn wait_for_fences(
22733 &self,
22734 fences: &[crate::vk1_0::Fence],
22735 wait_all: bool,
22736 timeout: u64,
22737 ) -> crate::utils::VulkanResult<()> {
22738 let _function = self.wait_for_fences.expect(crate::NOT_LOADED_MESSAGE);
22739 let fence_count = fences.len();
22740 let _return = _function(
22741 self.handle,
22742 fence_count as _,
22743 fences.as_ptr() as _,
22744 wait_all as _,
22745 timeout as _,
22746 );
22747 crate::utils::VulkanResult::new(_return, ())
22748 }
22749 #[inline]
22750 #[track_caller]
22751 #[doc(alias = "vkCreateSemaphore")]
22753 pub unsafe fn create_semaphore(
22754 &self,
22755 create_info: &crate::vk1_0::SemaphoreCreateInfo,
22756 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22757 ) -> crate::utils::VulkanResult<crate::vk1_0::Semaphore> {
22758 let _function = self.create_semaphore.expect(crate::NOT_LOADED_MESSAGE);
22759 let mut semaphore = Default::default();
22760 let _return = _function(
22761 self.handle,
22762 create_info as _,
22763 match allocator {
22764 Some(v) => v,
22765 None => std::ptr::null(),
22766 },
22767 &mut semaphore,
22768 );
22769 crate::utils::VulkanResult::new(_return, semaphore)
22770 }
22771 #[inline]
22772 #[track_caller]
22773 #[doc(alias = "vkDestroySemaphore")]
22775 pub unsafe fn destroy_semaphore(
22776 &self,
22777 semaphore: crate::vk1_0::Semaphore,
22778 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22779 ) -> () {
22780 let _function = self.destroy_semaphore.expect(crate::NOT_LOADED_MESSAGE);
22781 let _return = _function(
22782 self.handle,
22783 semaphore as _,
22784 match allocator {
22785 Some(v) => v,
22786 None => std::ptr::null(),
22787 },
22788 );
22789 ()
22790 }
22791 #[inline]
22792 #[track_caller]
22793 #[doc(alias = "vkCreateEvent")]
22795 pub unsafe fn create_event(
22796 &self,
22797 create_info: &crate::vk1_0::EventCreateInfo,
22798 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22799 ) -> crate::utils::VulkanResult<crate::vk1_0::Event> {
22800 let _function = self.create_event.expect(crate::NOT_LOADED_MESSAGE);
22801 let mut event = Default::default();
22802 let _return = _function(
22803 self.handle,
22804 create_info as _,
22805 match allocator {
22806 Some(v) => v,
22807 None => std::ptr::null(),
22808 },
22809 &mut event,
22810 );
22811 crate::utils::VulkanResult::new(_return, event)
22812 }
22813 #[inline]
22814 #[track_caller]
22815 #[doc(alias = "vkDestroyEvent")]
22817 pub unsafe fn destroy_event(
22818 &self,
22819 event: crate::vk1_0::Event,
22820 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22821 ) -> () {
22822 let _function = self.destroy_event.expect(crate::NOT_LOADED_MESSAGE);
22823 let _return = _function(
22824 self.handle,
22825 event as _,
22826 match allocator {
22827 Some(v) => v,
22828 None => std::ptr::null(),
22829 },
22830 );
22831 ()
22832 }
22833 #[inline]
22834 #[track_caller]
22835 #[doc(alias = "vkGetEventStatus")]
22837 pub unsafe fn get_event_status(
22838 &self,
22839 event: crate::vk1_0::Event,
22840 ) -> crate::utils::VulkanResult<()> {
22841 let _function = self.get_event_status.expect(crate::NOT_LOADED_MESSAGE);
22842 let _return = _function(self.handle, event as _);
22843 crate::utils::VulkanResult::new(_return, ())
22844 }
22845 #[inline]
22846 #[track_caller]
22847 #[doc(alias = "vkSetEvent")]
22849 pub unsafe fn set_event(
22850 &self,
22851 event: crate::vk1_0::Event,
22852 ) -> crate::utils::VulkanResult<()> {
22853 let _function = self.set_event.expect(crate::NOT_LOADED_MESSAGE);
22854 let _return = _function(self.handle, event as _);
22855 crate::utils::VulkanResult::new(_return, ())
22856 }
22857 #[inline]
22858 #[track_caller]
22859 #[doc(alias = "vkResetEvent")]
22861 pub unsafe fn reset_event(
22862 &self,
22863 event: crate::vk1_0::Event,
22864 ) -> crate::utils::VulkanResult<()> {
22865 let _function = self.reset_event.expect(crate::NOT_LOADED_MESSAGE);
22866 let _return = _function(self.handle, event as _);
22867 crate::utils::VulkanResult::new(_return, ())
22868 }
22869 #[inline]
22870 #[track_caller]
22871 #[doc(alias = "vkCreateQueryPool")]
22873 pub unsafe fn create_query_pool(
22874 &self,
22875 create_info: &crate::vk1_0::QueryPoolCreateInfo,
22876 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22877 ) -> crate::utils::VulkanResult<crate::vk1_0::QueryPool> {
22878 let _function = self.create_query_pool.expect(crate::NOT_LOADED_MESSAGE);
22879 let mut query_pool = Default::default();
22880 let _return = _function(
22881 self.handle,
22882 create_info as _,
22883 match allocator {
22884 Some(v) => v,
22885 None => std::ptr::null(),
22886 },
22887 &mut query_pool,
22888 );
22889 crate::utils::VulkanResult::new(_return, query_pool)
22890 }
22891 #[inline]
22892 #[track_caller]
22893 #[doc(alias = "vkDestroyQueryPool")]
22895 pub unsafe fn destroy_query_pool(
22896 &self,
22897 query_pool: crate::vk1_0::QueryPool,
22898 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22899 ) -> () {
22900 let _function = self.destroy_query_pool.expect(crate::NOT_LOADED_MESSAGE);
22901 let _return = _function(
22902 self.handle,
22903 query_pool as _,
22904 match allocator {
22905 Some(v) => v,
22906 None => std::ptr::null(),
22907 },
22908 );
22909 ()
22910 }
22911 #[inline]
22912 #[track_caller]
22913 #[doc(alias = "vkGetQueryPoolResults")]
22915 pub unsafe fn get_query_pool_results(
22916 &self,
22917 query_pool: crate::vk1_0::QueryPool,
22918 first_query: u32,
22919 query_count: u32,
22920 data_size: usize,
22921 data: *mut std::ffi::c_void,
22922 stride: crate::vk1_0::DeviceSize,
22923 flags: crate::vk1_0::QueryResultFlags,
22924 ) -> crate::utils::VulkanResult<()> {
22925 let _function = self.get_query_pool_results.expect(crate::NOT_LOADED_MESSAGE);
22926 let _return = _function(
22927 self.handle,
22928 query_pool as _,
22929 first_query as _,
22930 query_count as _,
22931 data_size,
22932 data,
22933 stride as _,
22934 flags as _,
22935 );
22936 crate::utils::VulkanResult::new(_return, ())
22937 }
22938 #[inline]
22939 #[track_caller]
22940 #[doc(alias = "vkCreateBuffer")]
22942 pub unsafe fn create_buffer(
22943 &self,
22944 create_info: &crate::vk1_0::BufferCreateInfo,
22945 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22946 ) -> crate::utils::VulkanResult<crate::vk1_0::Buffer> {
22947 let _function = self.create_buffer.expect(crate::NOT_LOADED_MESSAGE);
22948 let mut buffer = Default::default();
22949 let _return = _function(
22950 self.handle,
22951 create_info as _,
22952 match allocator {
22953 Some(v) => v,
22954 None => std::ptr::null(),
22955 },
22956 &mut buffer,
22957 );
22958 crate::utils::VulkanResult::new(_return, buffer)
22959 }
22960 #[inline]
22961 #[track_caller]
22962 #[doc(alias = "vkDestroyBuffer")]
22964 pub unsafe fn destroy_buffer(
22965 &self,
22966 buffer: crate::vk1_0::Buffer,
22967 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22968 ) -> () {
22969 let _function = self.destroy_buffer.expect(crate::NOT_LOADED_MESSAGE);
22970 let _return = _function(
22971 self.handle,
22972 buffer as _,
22973 match allocator {
22974 Some(v) => v,
22975 None => std::ptr::null(),
22976 },
22977 );
22978 ()
22979 }
22980 #[inline]
22981 #[track_caller]
22982 #[doc(alias = "vkCreateBufferView")]
22984 pub unsafe fn create_buffer_view(
22985 &self,
22986 create_info: &crate::vk1_0::BufferViewCreateInfo,
22987 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
22988 ) -> crate::utils::VulkanResult<crate::vk1_0::BufferView> {
22989 let _function = self.create_buffer_view.expect(crate::NOT_LOADED_MESSAGE);
22990 let mut view = Default::default();
22991 let _return = _function(
22992 self.handle,
22993 create_info as _,
22994 match allocator {
22995 Some(v) => v,
22996 None => std::ptr::null(),
22997 },
22998 &mut view,
22999 );
23000 crate::utils::VulkanResult::new(_return, view)
23001 }
23002 #[inline]
23003 #[track_caller]
23004 #[doc(alias = "vkDestroyBufferView")]
23006 pub unsafe fn destroy_buffer_view(
23007 &self,
23008 buffer_view: crate::vk1_0::BufferView,
23009 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23010 ) -> () {
23011 let _function = self.destroy_buffer_view.expect(crate::NOT_LOADED_MESSAGE);
23012 let _return = _function(
23013 self.handle,
23014 buffer_view as _,
23015 match allocator {
23016 Some(v) => v,
23017 None => std::ptr::null(),
23018 },
23019 );
23020 ()
23021 }
23022 #[inline]
23023 #[track_caller]
23024 #[doc(alias = "vkCreateImage")]
23026 pub unsafe fn create_image(
23027 &self,
23028 create_info: &crate::vk1_0::ImageCreateInfo,
23029 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23030 ) -> crate::utils::VulkanResult<crate::vk1_0::Image> {
23031 let _function = self.create_image.expect(crate::NOT_LOADED_MESSAGE);
23032 let mut image = Default::default();
23033 let _return = _function(
23034 self.handle,
23035 create_info as _,
23036 match allocator {
23037 Some(v) => v,
23038 None => std::ptr::null(),
23039 },
23040 &mut image,
23041 );
23042 crate::utils::VulkanResult::new(_return, image)
23043 }
23044 #[inline]
23045 #[track_caller]
23046 #[doc(alias = "vkDestroyImage")]
23048 pub unsafe fn destroy_image(
23049 &self,
23050 image: crate::vk1_0::Image,
23051 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23052 ) -> () {
23053 let _function = self.destroy_image.expect(crate::NOT_LOADED_MESSAGE);
23054 let _return = _function(
23055 self.handle,
23056 image as _,
23057 match allocator {
23058 Some(v) => v,
23059 None => std::ptr::null(),
23060 },
23061 );
23062 ()
23063 }
23064 #[inline]
23065 #[track_caller]
23066 #[doc(alias = "vkGetImageSubresourceLayout")]
23068 pub unsafe fn get_image_subresource_layout(
23069 &self,
23070 image: crate::vk1_0::Image,
23071 subresource: &crate::vk1_0::ImageSubresource,
23072 ) -> crate::vk1_0::SubresourceLayout {
23073 let _function = self
23074 .get_image_subresource_layout
23075 .expect(crate::NOT_LOADED_MESSAGE);
23076 let mut layout = Default::default();
23077 let _return = _function(self.handle, image as _, subresource as _, &mut layout);
23078 layout
23079 }
23080 #[inline]
23081 #[track_caller]
23082 #[doc(alias = "vkCreateImageView")]
23084 pub unsafe fn create_image_view(
23085 &self,
23086 create_info: &crate::vk1_0::ImageViewCreateInfo,
23087 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23088 ) -> crate::utils::VulkanResult<crate::vk1_0::ImageView> {
23089 let _function = self.create_image_view.expect(crate::NOT_LOADED_MESSAGE);
23090 let mut view = Default::default();
23091 let _return = _function(
23092 self.handle,
23093 create_info as _,
23094 match allocator {
23095 Some(v) => v,
23096 None => std::ptr::null(),
23097 },
23098 &mut view,
23099 );
23100 crate::utils::VulkanResult::new(_return, view)
23101 }
23102 #[inline]
23103 #[track_caller]
23104 #[doc(alias = "vkDestroyImageView")]
23106 pub unsafe fn destroy_image_view(
23107 &self,
23108 image_view: crate::vk1_0::ImageView,
23109 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23110 ) -> () {
23111 let _function = self.destroy_image_view.expect(crate::NOT_LOADED_MESSAGE);
23112 let _return = _function(
23113 self.handle,
23114 image_view as _,
23115 match allocator {
23116 Some(v) => v,
23117 None => std::ptr::null(),
23118 },
23119 );
23120 ()
23121 }
23122 #[inline]
23123 #[track_caller]
23124 #[doc(alias = "vkCreateShaderModule")]
23126 pub unsafe fn create_shader_module(
23127 &self,
23128 create_info: &crate::vk1_0::ShaderModuleCreateInfo,
23129 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23130 ) -> crate::utils::VulkanResult<crate::vk1_0::ShaderModule> {
23131 let _function = self.create_shader_module.expect(crate::NOT_LOADED_MESSAGE);
23132 let mut shader_module = Default::default();
23133 let _return = _function(
23134 self.handle,
23135 create_info as _,
23136 match allocator {
23137 Some(v) => v,
23138 None => std::ptr::null(),
23139 },
23140 &mut shader_module,
23141 );
23142 crate::utils::VulkanResult::new(_return, shader_module)
23143 }
23144 #[inline]
23145 #[track_caller]
23146 #[doc(alias = "vkDestroyShaderModule")]
23148 pub unsafe fn destroy_shader_module(
23149 &self,
23150 shader_module: crate::vk1_0::ShaderModule,
23151 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23152 ) -> () {
23153 let _function = self.destroy_shader_module.expect(crate::NOT_LOADED_MESSAGE);
23154 let _return = _function(
23155 self.handle,
23156 shader_module as _,
23157 match allocator {
23158 Some(v) => v,
23159 None => std::ptr::null(),
23160 },
23161 );
23162 ()
23163 }
23164 #[inline]
23165 #[track_caller]
23166 #[doc(alias = "vkCreatePipelineCache")]
23168 pub unsafe fn create_pipeline_cache(
23169 &self,
23170 create_info: &crate::vk1_0::PipelineCacheCreateInfo,
23171 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23172 ) -> crate::utils::VulkanResult<crate::vk1_0::PipelineCache> {
23173 let _function = self.create_pipeline_cache.expect(crate::NOT_LOADED_MESSAGE);
23174 let mut pipeline_cache = Default::default();
23175 let _return = _function(
23176 self.handle,
23177 create_info as _,
23178 match allocator {
23179 Some(v) => v,
23180 None => std::ptr::null(),
23181 },
23182 &mut pipeline_cache,
23183 );
23184 crate::utils::VulkanResult::new(_return, pipeline_cache)
23185 }
23186 #[inline]
23187 #[track_caller]
23188 #[doc(alias = "vkDestroyPipelineCache")]
23190 pub unsafe fn destroy_pipeline_cache(
23191 &self,
23192 pipeline_cache: crate::vk1_0::PipelineCache,
23193 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23194 ) -> () {
23195 let _function = self.destroy_pipeline_cache.expect(crate::NOT_LOADED_MESSAGE);
23196 let _return = _function(
23197 self.handle,
23198 pipeline_cache as _,
23199 match allocator {
23200 Some(v) => v,
23201 None => std::ptr::null(),
23202 },
23203 );
23204 ()
23205 }
23206 #[inline]
23207 #[track_caller]
23208 #[doc(alias = "vkGetPipelineCacheData")]
23210 pub unsafe fn get_pipeline_cache_data(
23211 &self,
23212 pipeline_cache: crate::vk1_0::PipelineCache,
23213 data_size: *mut usize,
23214 data: *mut std::ffi::c_void,
23215 ) -> crate::utils::VulkanResult<()> {
23216 let _function = self.get_pipeline_cache_data.expect(crate::NOT_LOADED_MESSAGE);
23217 let _return = _function(self.handle, pipeline_cache as _, data_size, data);
23218 crate::utils::VulkanResult::new(_return, ())
23219 }
23220 #[inline]
23221 #[track_caller]
23222 #[doc(alias = "vkMergePipelineCaches")]
23224 pub unsafe fn merge_pipeline_caches(
23225 &self,
23226 dst_cache: crate::vk1_0::PipelineCache,
23227 src_caches: &[crate::vk1_0::PipelineCache],
23228 ) -> crate::utils::VulkanResult<()> {
23229 let _function = self.merge_pipeline_caches.expect(crate::NOT_LOADED_MESSAGE);
23230 let src_cache_count = src_caches.len();
23231 let _return = _function(
23232 self.handle,
23233 dst_cache as _,
23234 src_cache_count as _,
23235 src_caches.as_ptr() as _,
23236 );
23237 crate::utils::VulkanResult::new(_return, ())
23238 }
23239 #[inline]
23240 #[track_caller]
23241 #[doc(alias = "vkCreateGraphicsPipelines")]
23243 pub unsafe fn create_graphics_pipelines(
23244 &self,
23245 pipeline_cache: crate::vk1_0::PipelineCache,
23246 create_infos: &[crate::vk1_0::GraphicsPipelineCreateInfoBuilder],
23247 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23248 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::Pipeline>> {
23249 let _function = self.create_graphics_pipelines.expect(crate::NOT_LOADED_MESSAGE);
23250 let create_info_count = create_infos.len();
23251 let mut pipelines = crate::SmallVec::from_elem(
23252 Default::default(),
23253 create_info_count as _,
23254 );
23255 let _return = _function(
23256 self.handle,
23257 pipeline_cache as _,
23258 create_info_count as _,
23259 create_infos.as_ptr() as _,
23260 match allocator {
23261 Some(v) => v,
23262 None => std::ptr::null(),
23263 },
23264 pipelines.as_mut_ptr(),
23265 );
23266 crate::utils::VulkanResult::new(_return, pipelines)
23267 }
23268 #[inline]
23269 #[track_caller]
23270 #[doc(alias = "vkCreateComputePipelines")]
23272 pub unsafe fn create_compute_pipelines(
23273 &self,
23274 pipeline_cache: crate::vk1_0::PipelineCache,
23275 create_infos: &[crate::vk1_0::ComputePipelineCreateInfoBuilder],
23276 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23277 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::Pipeline>> {
23278 let _function = self.create_compute_pipelines.expect(crate::NOT_LOADED_MESSAGE);
23279 let create_info_count = create_infos.len();
23280 let mut pipelines = crate::SmallVec::from_elem(
23281 Default::default(),
23282 create_info_count as _,
23283 );
23284 let _return = _function(
23285 self.handle,
23286 pipeline_cache as _,
23287 create_info_count as _,
23288 create_infos.as_ptr() as _,
23289 match allocator {
23290 Some(v) => v,
23291 None => std::ptr::null(),
23292 },
23293 pipelines.as_mut_ptr(),
23294 );
23295 crate::utils::VulkanResult::new(_return, pipelines)
23296 }
23297 #[inline]
23298 #[track_caller]
23299 #[doc(alias = "vkDestroyPipeline")]
23301 pub unsafe fn destroy_pipeline(
23302 &self,
23303 pipeline: crate::vk1_0::Pipeline,
23304 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23305 ) -> () {
23306 let _function = self.destroy_pipeline.expect(crate::NOT_LOADED_MESSAGE);
23307 let _return = _function(
23308 self.handle,
23309 pipeline as _,
23310 match allocator {
23311 Some(v) => v,
23312 None => std::ptr::null(),
23313 },
23314 );
23315 ()
23316 }
23317 #[inline]
23318 #[track_caller]
23319 #[doc(alias = "vkCreatePipelineLayout")]
23321 pub unsafe fn create_pipeline_layout(
23322 &self,
23323 create_info: &crate::vk1_0::PipelineLayoutCreateInfo,
23324 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23325 ) -> crate::utils::VulkanResult<crate::vk1_0::PipelineLayout> {
23326 let _function = self.create_pipeline_layout.expect(crate::NOT_LOADED_MESSAGE);
23327 let mut pipeline_layout = Default::default();
23328 let _return = _function(
23329 self.handle,
23330 create_info as _,
23331 match allocator {
23332 Some(v) => v,
23333 None => std::ptr::null(),
23334 },
23335 &mut pipeline_layout,
23336 );
23337 crate::utils::VulkanResult::new(_return, pipeline_layout)
23338 }
23339 #[inline]
23340 #[track_caller]
23341 #[doc(alias = "vkDestroyPipelineLayout")]
23343 pub unsafe fn destroy_pipeline_layout(
23344 &self,
23345 pipeline_layout: crate::vk1_0::PipelineLayout,
23346 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23347 ) -> () {
23348 let _function = self.destroy_pipeline_layout.expect(crate::NOT_LOADED_MESSAGE);
23349 let _return = _function(
23350 self.handle,
23351 pipeline_layout as _,
23352 match allocator {
23353 Some(v) => v,
23354 None => std::ptr::null(),
23355 },
23356 );
23357 ()
23358 }
23359 #[inline]
23360 #[track_caller]
23361 #[doc(alias = "vkCreateSampler")]
23363 pub unsafe fn create_sampler(
23364 &self,
23365 create_info: &crate::vk1_0::SamplerCreateInfo,
23366 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23367 ) -> crate::utils::VulkanResult<crate::vk1_0::Sampler> {
23368 let _function = self.create_sampler.expect(crate::NOT_LOADED_MESSAGE);
23369 let mut sampler = Default::default();
23370 let _return = _function(
23371 self.handle,
23372 create_info as _,
23373 match allocator {
23374 Some(v) => v,
23375 None => std::ptr::null(),
23376 },
23377 &mut sampler,
23378 );
23379 crate::utils::VulkanResult::new(_return, sampler)
23380 }
23381 #[inline]
23382 #[track_caller]
23383 #[doc(alias = "vkDestroySampler")]
23385 pub unsafe fn destroy_sampler(
23386 &self,
23387 sampler: crate::vk1_0::Sampler,
23388 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23389 ) -> () {
23390 let _function = self.destroy_sampler.expect(crate::NOT_LOADED_MESSAGE);
23391 let _return = _function(
23392 self.handle,
23393 sampler as _,
23394 match allocator {
23395 Some(v) => v,
23396 None => std::ptr::null(),
23397 },
23398 );
23399 ()
23400 }
23401 #[inline]
23402 #[track_caller]
23403 #[doc(alias = "vkCreateDescriptorSetLayout")]
23405 pub unsafe fn create_descriptor_set_layout(
23406 &self,
23407 create_info: &crate::vk1_0::DescriptorSetLayoutCreateInfo,
23408 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23409 ) -> crate::utils::VulkanResult<crate::vk1_0::DescriptorSetLayout> {
23410 let _function = self
23411 .create_descriptor_set_layout
23412 .expect(crate::NOT_LOADED_MESSAGE);
23413 let mut set_layout = Default::default();
23414 let _return = _function(
23415 self.handle,
23416 create_info as _,
23417 match allocator {
23418 Some(v) => v,
23419 None => std::ptr::null(),
23420 },
23421 &mut set_layout,
23422 );
23423 crate::utils::VulkanResult::new(_return, set_layout)
23424 }
23425 #[inline]
23426 #[track_caller]
23427 #[doc(alias = "vkDestroyDescriptorSetLayout")]
23429 pub unsafe fn destroy_descriptor_set_layout(
23430 &self,
23431 descriptor_set_layout: crate::vk1_0::DescriptorSetLayout,
23432 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23433 ) -> () {
23434 let _function = self
23435 .destroy_descriptor_set_layout
23436 .expect(crate::NOT_LOADED_MESSAGE);
23437 let _return = _function(
23438 self.handle,
23439 descriptor_set_layout as _,
23440 match allocator {
23441 Some(v) => v,
23442 None => std::ptr::null(),
23443 },
23444 );
23445 ()
23446 }
23447 #[inline]
23448 #[track_caller]
23449 #[doc(alias = "vkCreateDescriptorPool")]
23451 pub unsafe fn create_descriptor_pool(
23452 &self,
23453 create_info: &crate::vk1_0::DescriptorPoolCreateInfo,
23454 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23455 ) -> crate::utils::VulkanResult<crate::vk1_0::DescriptorPool> {
23456 let _function = self.create_descriptor_pool.expect(crate::NOT_LOADED_MESSAGE);
23457 let mut descriptor_pool = Default::default();
23458 let _return = _function(
23459 self.handle,
23460 create_info as _,
23461 match allocator {
23462 Some(v) => v,
23463 None => std::ptr::null(),
23464 },
23465 &mut descriptor_pool,
23466 );
23467 crate::utils::VulkanResult::new(_return, descriptor_pool)
23468 }
23469 #[inline]
23470 #[track_caller]
23471 #[doc(alias = "vkDestroyDescriptorPool")]
23473 pub unsafe fn destroy_descriptor_pool(
23474 &self,
23475 descriptor_pool: crate::vk1_0::DescriptorPool,
23476 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23477 ) -> () {
23478 let _function = self.destroy_descriptor_pool.expect(crate::NOT_LOADED_MESSAGE);
23479 let _return = _function(
23480 self.handle,
23481 descriptor_pool as _,
23482 match allocator {
23483 Some(v) => v,
23484 None => std::ptr::null(),
23485 },
23486 );
23487 ()
23488 }
23489 #[inline]
23490 #[track_caller]
23491 #[doc(alias = "vkResetDescriptorPool")]
23493 pub unsafe fn reset_descriptor_pool(
23494 &self,
23495 descriptor_pool: crate::vk1_0::DescriptorPool,
23496 flags: crate::vk1_0::DescriptorPoolResetFlags,
23497 ) -> crate::utils::VulkanResult<()> {
23498 let _function = self.reset_descriptor_pool.expect(crate::NOT_LOADED_MESSAGE);
23499 let _return = _function(self.handle, descriptor_pool as _, flags as _);
23500 crate::utils::VulkanResult::new(_return, ())
23501 }
23502 #[inline]
23503 #[track_caller]
23504 #[doc(alias = "vkAllocateDescriptorSets")]
23506 pub unsafe fn allocate_descriptor_sets(
23507 &self,
23508 allocate_info: &crate::vk1_0::DescriptorSetAllocateInfo,
23509 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::DescriptorSet>> {
23510 let _function = self.allocate_descriptor_sets.expect(crate::NOT_LOADED_MESSAGE);
23511 let mut descriptor_sets = crate::SmallVec::from_elem(
23512 Default::default(),
23513 allocate_info.descriptor_set_count as _,
23514 );
23515 let _return = _function(
23516 self.handle,
23517 allocate_info as _,
23518 descriptor_sets.as_mut_ptr(),
23519 );
23520 crate::utils::VulkanResult::new(_return, descriptor_sets)
23521 }
23522 #[inline]
23523 #[track_caller]
23524 #[doc(alias = "vkFreeDescriptorSets")]
23526 pub unsafe fn free_descriptor_sets(
23527 &self,
23528 descriptor_pool: crate::vk1_0::DescriptorPool,
23529 descriptor_sets: &[crate::vk1_0::DescriptorSet],
23530 ) -> crate::utils::VulkanResult<()> {
23531 let _function = self.free_descriptor_sets.expect(crate::NOT_LOADED_MESSAGE);
23532 let descriptor_set_count = descriptor_sets.len();
23533 let _return = _function(
23534 self.handle,
23535 descriptor_pool as _,
23536 descriptor_set_count as _,
23537 descriptor_sets.as_ptr() as _,
23538 );
23539 crate::utils::VulkanResult::new(_return, ())
23540 }
23541 #[inline]
23542 #[track_caller]
23543 #[doc(alias = "vkUpdateDescriptorSets")]
23545 pub unsafe fn update_descriptor_sets(
23546 &self,
23547 descriptor_writes: &[crate::vk1_0::WriteDescriptorSetBuilder],
23548 descriptor_copies: &[crate::vk1_0::CopyDescriptorSetBuilder],
23549 ) -> () {
23550 let _function = self.update_descriptor_sets.expect(crate::NOT_LOADED_MESSAGE);
23551 let descriptor_write_count = descriptor_writes.len();
23552 let descriptor_copy_count = descriptor_copies.len();
23553 let _return = _function(
23554 self.handle,
23555 descriptor_write_count as _,
23556 descriptor_writes.as_ptr() as _,
23557 descriptor_copy_count as _,
23558 descriptor_copies.as_ptr() as _,
23559 );
23560 ()
23561 }
23562 #[inline]
23563 #[track_caller]
23564 #[doc(alias = "vkCreateFramebuffer")]
23566 pub unsafe fn create_framebuffer(
23567 &self,
23568 create_info: &crate::vk1_0::FramebufferCreateInfo,
23569 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23570 ) -> crate::utils::VulkanResult<crate::vk1_0::Framebuffer> {
23571 let _function = self.create_framebuffer.expect(crate::NOT_LOADED_MESSAGE);
23572 let mut framebuffer = Default::default();
23573 let _return = _function(
23574 self.handle,
23575 create_info as _,
23576 match allocator {
23577 Some(v) => v,
23578 None => std::ptr::null(),
23579 },
23580 &mut framebuffer,
23581 );
23582 crate::utils::VulkanResult::new(_return, framebuffer)
23583 }
23584 #[inline]
23585 #[track_caller]
23586 #[doc(alias = "vkDestroyFramebuffer")]
23588 pub unsafe fn destroy_framebuffer(
23589 &self,
23590 framebuffer: crate::vk1_0::Framebuffer,
23591 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23592 ) -> () {
23593 let _function = self.destroy_framebuffer.expect(crate::NOT_LOADED_MESSAGE);
23594 let _return = _function(
23595 self.handle,
23596 framebuffer as _,
23597 match allocator {
23598 Some(v) => v,
23599 None => std::ptr::null(),
23600 },
23601 );
23602 ()
23603 }
23604 #[inline]
23605 #[track_caller]
23606 #[doc(alias = "vkCreateRenderPass")]
23608 pub unsafe fn create_render_pass(
23609 &self,
23610 create_info: &crate::vk1_0::RenderPassCreateInfo,
23611 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23612 ) -> crate::utils::VulkanResult<crate::vk1_0::RenderPass> {
23613 let _function = self.create_render_pass.expect(crate::NOT_LOADED_MESSAGE);
23614 let mut render_pass = Default::default();
23615 let _return = _function(
23616 self.handle,
23617 create_info as _,
23618 match allocator {
23619 Some(v) => v,
23620 None => std::ptr::null(),
23621 },
23622 &mut render_pass,
23623 );
23624 crate::utils::VulkanResult::new(_return, render_pass)
23625 }
23626 #[inline]
23627 #[track_caller]
23628 #[doc(alias = "vkDestroyRenderPass")]
23630 pub unsafe fn destroy_render_pass(
23631 &self,
23632 render_pass: crate::vk1_0::RenderPass,
23633 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23634 ) -> () {
23635 let _function = self.destroy_render_pass.expect(crate::NOT_LOADED_MESSAGE);
23636 let _return = _function(
23637 self.handle,
23638 render_pass as _,
23639 match allocator {
23640 Some(v) => v,
23641 None => std::ptr::null(),
23642 },
23643 );
23644 ()
23645 }
23646 #[inline]
23647 #[track_caller]
23648 #[doc(alias = "vkGetRenderAreaGranularity")]
23650 pub unsafe fn get_render_area_granularity(
23651 &self,
23652 render_pass: crate::vk1_0::RenderPass,
23653 ) -> crate::vk1_0::Extent2D {
23654 let _function = self
23655 .get_render_area_granularity
23656 .expect(crate::NOT_LOADED_MESSAGE);
23657 let mut granularity = Default::default();
23658 let _return = _function(self.handle, render_pass as _, &mut granularity);
23659 granularity
23660 }
23661 #[inline]
23662 #[track_caller]
23663 #[doc(alias = "vkCreateCommandPool")]
23665 pub unsafe fn create_command_pool(
23666 &self,
23667 create_info: &crate::vk1_0::CommandPoolCreateInfo,
23668 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23669 ) -> crate::utils::VulkanResult<crate::vk1_0::CommandPool> {
23670 let _function = self.create_command_pool.expect(crate::NOT_LOADED_MESSAGE);
23671 let mut command_pool = Default::default();
23672 let _return = _function(
23673 self.handle,
23674 create_info as _,
23675 match allocator {
23676 Some(v) => v,
23677 None => std::ptr::null(),
23678 },
23679 &mut command_pool,
23680 );
23681 crate::utils::VulkanResult::new(_return, command_pool)
23682 }
23683 #[inline]
23684 #[track_caller]
23685 #[doc(alias = "vkDestroyCommandPool")]
23687 pub unsafe fn destroy_command_pool(
23688 &self,
23689 command_pool: crate::vk1_0::CommandPool,
23690 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
23691 ) -> () {
23692 let _function = self.destroy_command_pool.expect(crate::NOT_LOADED_MESSAGE);
23693 let _return = _function(
23694 self.handle,
23695 command_pool as _,
23696 match allocator {
23697 Some(v) => v,
23698 None => std::ptr::null(),
23699 },
23700 );
23701 ()
23702 }
23703 #[inline]
23704 #[track_caller]
23705 #[doc(alias = "vkResetCommandPool")]
23707 pub unsafe fn reset_command_pool(
23708 &self,
23709 command_pool: crate::vk1_0::CommandPool,
23710 flags: crate::vk1_0::CommandPoolResetFlags,
23711 ) -> crate::utils::VulkanResult<()> {
23712 let _function = self.reset_command_pool.expect(crate::NOT_LOADED_MESSAGE);
23713 let _return = _function(self.handle, command_pool as _, flags as _);
23714 crate::utils::VulkanResult::new(_return, ())
23715 }
23716 #[inline]
23717 #[track_caller]
23718 #[doc(alias = "vkAllocateCommandBuffers")]
23720 pub unsafe fn allocate_command_buffers(
23721 &self,
23722 allocate_info: &crate::vk1_0::CommandBufferAllocateInfo,
23723 ) -> crate::utils::VulkanResult<crate::SmallVec<crate::vk1_0::CommandBuffer>> {
23724 let _function = self.allocate_command_buffers.expect(crate::NOT_LOADED_MESSAGE);
23725 let mut command_buffers = crate::SmallVec::from_elem(
23726 Default::default(),
23727 allocate_info.command_buffer_count as _,
23728 );
23729 let _return = _function(
23730 self.handle,
23731 allocate_info as _,
23732 command_buffers.as_mut_ptr(),
23733 );
23734 crate::utils::VulkanResult::new(_return, command_buffers)
23735 }
23736 #[inline]
23737 #[track_caller]
23738 #[doc(alias = "vkFreeCommandBuffers")]
23740 pub unsafe fn free_command_buffers(
23741 &self,
23742 command_pool: crate::vk1_0::CommandPool,
23743 command_buffers: &[crate::vk1_0::CommandBuffer],
23744 ) -> () {
23745 let _function = self.free_command_buffers.expect(crate::NOT_LOADED_MESSAGE);
23746 let command_buffer_count = command_buffers.len();
23747 let _return = _function(
23748 self.handle,
23749 command_pool as _,
23750 command_buffer_count as _,
23751 command_buffers.as_ptr() as _,
23752 );
23753 ()
23754 }
23755 #[inline]
23756 #[track_caller]
23757 #[doc(alias = "vkBeginCommandBuffer")]
23759 pub unsafe fn begin_command_buffer(
23760 &self,
23761 command_buffer: crate::vk1_0::CommandBuffer,
23762 begin_info: &crate::vk1_0::CommandBufferBeginInfo,
23763 ) -> crate::utils::VulkanResult<()> {
23764 let _function = self.begin_command_buffer.expect(crate::NOT_LOADED_MESSAGE);
23765 let _return = _function(command_buffer as _, begin_info as _);
23766 crate::utils::VulkanResult::new(_return, ())
23767 }
23768 #[inline]
23769 #[track_caller]
23770 #[doc(alias = "vkEndCommandBuffer")]
23772 pub unsafe fn end_command_buffer(
23773 &self,
23774 command_buffer: crate::vk1_0::CommandBuffer,
23775 ) -> crate::utils::VulkanResult<()> {
23776 let _function = self.end_command_buffer.expect(crate::NOT_LOADED_MESSAGE);
23777 let _return = _function(command_buffer as _);
23778 crate::utils::VulkanResult::new(_return, ())
23779 }
23780 #[inline]
23781 #[track_caller]
23782 #[doc(alias = "vkResetCommandBuffer")]
23784 pub unsafe fn reset_command_buffer(
23785 &self,
23786 command_buffer: crate::vk1_0::CommandBuffer,
23787 flags: crate::vk1_0::CommandBufferResetFlags,
23788 ) -> crate::utils::VulkanResult<()> {
23789 let _function = self.reset_command_buffer.expect(crate::NOT_LOADED_MESSAGE);
23790 let _return = _function(command_buffer as _, flags as _);
23791 crate::utils::VulkanResult::new(_return, ())
23792 }
23793 #[inline]
23794 #[track_caller]
23795 #[doc(alias = "vkCmdBindPipeline")]
23797 pub unsafe fn cmd_bind_pipeline(
23798 &self,
23799 command_buffer: crate::vk1_0::CommandBuffer,
23800 pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
23801 pipeline: crate::vk1_0::Pipeline,
23802 ) -> () {
23803 let _function = self.cmd_bind_pipeline.expect(crate::NOT_LOADED_MESSAGE);
23804 let _return = _function(
23805 command_buffer as _,
23806 pipeline_bind_point as _,
23807 pipeline as _,
23808 );
23809 ()
23810 }
23811 #[inline]
23812 #[track_caller]
23813 #[doc(alias = "vkCmdSetViewport")]
23815 pub unsafe fn cmd_set_viewport(
23816 &self,
23817 command_buffer: crate::vk1_0::CommandBuffer,
23818 first_viewport: u32,
23819 viewports: &[crate::vk1_0::ViewportBuilder],
23820 ) -> () {
23821 let _function = self.cmd_set_viewport.expect(crate::NOT_LOADED_MESSAGE);
23822 let viewport_count = viewports.len();
23823 let _return = _function(
23824 command_buffer as _,
23825 first_viewport as _,
23826 viewport_count as _,
23827 viewports.as_ptr() as _,
23828 );
23829 ()
23830 }
23831 #[inline]
23832 #[track_caller]
23833 #[doc(alias = "vkCmdSetScissor")]
23835 pub unsafe fn cmd_set_scissor(
23836 &self,
23837 command_buffer: crate::vk1_0::CommandBuffer,
23838 first_scissor: u32,
23839 scissors: &[crate::vk1_0::Rect2DBuilder],
23840 ) -> () {
23841 let _function = self.cmd_set_scissor.expect(crate::NOT_LOADED_MESSAGE);
23842 let scissor_count = scissors.len();
23843 let _return = _function(
23844 command_buffer as _,
23845 first_scissor as _,
23846 scissor_count as _,
23847 scissors.as_ptr() as _,
23848 );
23849 ()
23850 }
23851 #[inline]
23852 #[track_caller]
23853 #[doc(alias = "vkCmdSetLineWidth")]
23855 pub unsafe fn cmd_set_line_width(
23856 &self,
23857 command_buffer: crate::vk1_0::CommandBuffer,
23858 line_width: std::os::raw::c_float,
23859 ) -> () {
23860 let _function = self.cmd_set_line_width.expect(crate::NOT_LOADED_MESSAGE);
23861 let _return = _function(command_buffer as _, line_width as _);
23862 ()
23863 }
23864 #[inline]
23865 #[track_caller]
23866 #[doc(alias = "vkCmdSetDepthBias")]
23868 pub unsafe fn cmd_set_depth_bias(
23869 &self,
23870 command_buffer: crate::vk1_0::CommandBuffer,
23871 depth_bias_constant_factor: std::os::raw::c_float,
23872 depth_bias_clamp: std::os::raw::c_float,
23873 depth_bias_slope_factor: std::os::raw::c_float,
23874 ) -> () {
23875 let _function = self.cmd_set_depth_bias.expect(crate::NOT_LOADED_MESSAGE);
23876 let _return = _function(
23877 command_buffer as _,
23878 depth_bias_constant_factor as _,
23879 depth_bias_clamp as _,
23880 depth_bias_slope_factor as _,
23881 );
23882 ()
23883 }
23884 #[inline]
23885 #[track_caller]
23886 #[doc(alias = "vkCmdSetBlendConstants")]
23888 pub unsafe fn cmd_set_blend_constants(
23889 &self,
23890 command_buffer: crate::vk1_0::CommandBuffer,
23891 blend_constants: [std::os::raw::c_float; 4],
23892 ) -> () {
23893 let _function = self.cmd_set_blend_constants.expect(crate::NOT_LOADED_MESSAGE);
23894 let _return = _function(command_buffer as _, blend_constants as _);
23895 ()
23896 }
23897 #[inline]
23898 #[track_caller]
23899 #[doc(alias = "vkCmdSetDepthBounds")]
23901 pub unsafe fn cmd_set_depth_bounds(
23902 &self,
23903 command_buffer: crate::vk1_0::CommandBuffer,
23904 min_depth_bounds: std::os::raw::c_float,
23905 max_depth_bounds: std::os::raw::c_float,
23906 ) -> () {
23907 let _function = self.cmd_set_depth_bounds.expect(crate::NOT_LOADED_MESSAGE);
23908 let _return = _function(
23909 command_buffer as _,
23910 min_depth_bounds as _,
23911 max_depth_bounds as _,
23912 );
23913 ()
23914 }
23915 #[inline]
23916 #[track_caller]
23917 #[doc(alias = "vkCmdSetStencilCompareMask")]
23919 pub unsafe fn cmd_set_stencil_compare_mask(
23920 &self,
23921 command_buffer: crate::vk1_0::CommandBuffer,
23922 face_mask: crate::vk1_0::StencilFaceFlags,
23923 compare_mask: u32,
23924 ) -> () {
23925 let _function = self
23926 .cmd_set_stencil_compare_mask
23927 .expect(crate::NOT_LOADED_MESSAGE);
23928 let _return = _function(command_buffer as _, face_mask as _, compare_mask as _);
23929 ()
23930 }
23931 #[inline]
23932 #[track_caller]
23933 #[doc(alias = "vkCmdSetStencilWriteMask")]
23935 pub unsafe fn cmd_set_stencil_write_mask(
23936 &self,
23937 command_buffer: crate::vk1_0::CommandBuffer,
23938 face_mask: crate::vk1_0::StencilFaceFlags,
23939 write_mask: u32,
23940 ) -> () {
23941 let _function = self
23942 .cmd_set_stencil_write_mask
23943 .expect(crate::NOT_LOADED_MESSAGE);
23944 let _return = _function(command_buffer as _, face_mask as _, write_mask as _);
23945 ()
23946 }
23947 #[inline]
23948 #[track_caller]
23949 #[doc(alias = "vkCmdSetStencilReference")]
23951 pub unsafe fn cmd_set_stencil_reference(
23952 &self,
23953 command_buffer: crate::vk1_0::CommandBuffer,
23954 face_mask: crate::vk1_0::StencilFaceFlags,
23955 reference: u32,
23956 ) -> () {
23957 let _function = self.cmd_set_stencil_reference.expect(crate::NOT_LOADED_MESSAGE);
23958 let _return = _function(command_buffer as _, face_mask as _, reference as _);
23959 ()
23960 }
23961 #[inline]
23962 #[track_caller]
23963 #[doc(alias = "vkCmdBindDescriptorSets")]
23965 pub unsafe fn cmd_bind_descriptor_sets(
23966 &self,
23967 command_buffer: crate::vk1_0::CommandBuffer,
23968 pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
23969 layout: crate::vk1_0::PipelineLayout,
23970 first_set: u32,
23971 descriptor_sets: &[crate::vk1_0::DescriptorSet],
23972 dynamic_offsets: &[u32],
23973 ) -> () {
23974 let _function = self.cmd_bind_descriptor_sets.expect(crate::NOT_LOADED_MESSAGE);
23975 let descriptor_set_count = descriptor_sets.len();
23976 let dynamic_offset_count = dynamic_offsets.len();
23977 let _return = _function(
23978 command_buffer as _,
23979 pipeline_bind_point as _,
23980 layout as _,
23981 first_set as _,
23982 descriptor_set_count as _,
23983 descriptor_sets.as_ptr() as _,
23984 dynamic_offset_count as _,
23985 dynamic_offsets.as_ptr() as _,
23986 );
23987 ()
23988 }
23989 #[inline]
23990 #[track_caller]
23991 #[doc(alias = "vkCmdBindIndexBuffer")]
23993 pub unsafe fn cmd_bind_index_buffer(
23994 &self,
23995 command_buffer: crate::vk1_0::CommandBuffer,
23996 buffer: crate::vk1_0::Buffer,
23997 offset: crate::vk1_0::DeviceSize,
23998 index_type: crate::vk1_0::IndexType,
23999 ) -> () {
24000 let _function = self.cmd_bind_index_buffer.expect(crate::NOT_LOADED_MESSAGE);
24001 let _return = _function(
24002 command_buffer as _,
24003 buffer as _,
24004 offset as _,
24005 index_type as _,
24006 );
24007 ()
24008 }
24009 #[inline]
24010 #[track_caller]
24011 #[doc(alias = "vkCmdBindVertexBuffers")]
24013 pub unsafe fn cmd_bind_vertex_buffers(
24014 &self,
24015 command_buffer: crate::vk1_0::CommandBuffer,
24016 first_binding: u32,
24017 buffers: &[crate::vk1_0::Buffer],
24018 offsets: &[crate::vk1_0::DeviceSize],
24019 ) -> () {
24020 let _function = self.cmd_bind_vertex_buffers.expect(crate::NOT_LOADED_MESSAGE);
24021 let binding_count = buffers.len().min(offsets.len());
24022 let _return = _function(
24023 command_buffer as _,
24024 first_binding as _,
24025 binding_count as _,
24026 buffers.as_ptr() as _,
24027 offsets.as_ptr() as _,
24028 );
24029 ()
24030 }
24031 #[inline]
24032 #[track_caller]
24033 #[doc(alias = "vkCmdDraw")]
24035 pub unsafe fn cmd_draw(
24036 &self,
24037 command_buffer: crate::vk1_0::CommandBuffer,
24038 vertex_count: u32,
24039 instance_count: u32,
24040 first_vertex: u32,
24041 first_instance: u32,
24042 ) -> () {
24043 let _function = self.cmd_draw.expect(crate::NOT_LOADED_MESSAGE);
24044 let _return = _function(
24045 command_buffer as _,
24046 vertex_count as _,
24047 instance_count as _,
24048 first_vertex as _,
24049 first_instance as _,
24050 );
24051 ()
24052 }
24053 #[inline]
24054 #[track_caller]
24055 #[doc(alias = "vkCmdDrawIndexed")]
24057 pub unsafe fn cmd_draw_indexed(
24058 &self,
24059 command_buffer: crate::vk1_0::CommandBuffer,
24060 index_count: u32,
24061 instance_count: u32,
24062 first_index: u32,
24063 vertex_offset: i32,
24064 first_instance: u32,
24065 ) -> () {
24066 let _function = self.cmd_draw_indexed.expect(crate::NOT_LOADED_MESSAGE);
24067 let _return = _function(
24068 command_buffer as _,
24069 index_count as _,
24070 instance_count as _,
24071 first_index as _,
24072 vertex_offset as _,
24073 first_instance as _,
24074 );
24075 ()
24076 }
24077 #[inline]
24078 #[track_caller]
24079 #[doc(alias = "vkCmdDrawIndirect")]
24081 pub unsafe fn cmd_draw_indirect(
24082 &self,
24083 command_buffer: crate::vk1_0::CommandBuffer,
24084 buffer: crate::vk1_0::Buffer,
24085 offset: crate::vk1_0::DeviceSize,
24086 draw_count: u32,
24087 stride: u32,
24088 ) -> () {
24089 let _function = self.cmd_draw_indirect.expect(crate::NOT_LOADED_MESSAGE);
24090 let _return = _function(
24091 command_buffer as _,
24092 buffer as _,
24093 offset as _,
24094 draw_count as _,
24095 stride as _,
24096 );
24097 ()
24098 }
24099 #[inline]
24100 #[track_caller]
24101 #[doc(alias = "vkCmdDrawIndexedIndirect")]
24103 pub unsafe fn cmd_draw_indexed_indirect(
24104 &self,
24105 command_buffer: crate::vk1_0::CommandBuffer,
24106 buffer: crate::vk1_0::Buffer,
24107 offset: crate::vk1_0::DeviceSize,
24108 draw_count: u32,
24109 stride: u32,
24110 ) -> () {
24111 let _function = self.cmd_draw_indexed_indirect.expect(crate::NOT_LOADED_MESSAGE);
24112 let _return = _function(
24113 command_buffer as _,
24114 buffer as _,
24115 offset as _,
24116 draw_count as _,
24117 stride as _,
24118 );
24119 ()
24120 }
24121 #[inline]
24122 #[track_caller]
24123 #[doc(alias = "vkCmdDispatch")]
24125 pub unsafe fn cmd_dispatch(
24126 &self,
24127 command_buffer: crate::vk1_0::CommandBuffer,
24128 group_count_x: u32,
24129 group_count_y: u32,
24130 group_count_z: u32,
24131 ) -> () {
24132 let _function = self.cmd_dispatch.expect(crate::NOT_LOADED_MESSAGE);
24133 let _return = _function(
24134 command_buffer as _,
24135 group_count_x as _,
24136 group_count_y as _,
24137 group_count_z as _,
24138 );
24139 ()
24140 }
24141 #[inline]
24142 #[track_caller]
24143 #[doc(alias = "vkCmdDispatchIndirect")]
24145 pub unsafe fn cmd_dispatch_indirect(
24146 &self,
24147 command_buffer: crate::vk1_0::CommandBuffer,
24148 buffer: crate::vk1_0::Buffer,
24149 offset: crate::vk1_0::DeviceSize,
24150 ) -> () {
24151 let _function = self.cmd_dispatch_indirect.expect(crate::NOT_LOADED_MESSAGE);
24152 let _return = _function(command_buffer as _, buffer as _, offset as _);
24153 ()
24154 }
24155 #[inline]
24156 #[track_caller]
24157 #[doc(alias = "vkCmdCopyBuffer")]
24159 pub unsafe fn cmd_copy_buffer(
24160 &self,
24161 command_buffer: crate::vk1_0::CommandBuffer,
24162 src_buffer: crate::vk1_0::Buffer,
24163 dst_buffer: crate::vk1_0::Buffer,
24164 regions: &[crate::vk1_0::BufferCopyBuilder],
24165 ) -> () {
24166 let _function = self.cmd_copy_buffer.expect(crate::NOT_LOADED_MESSAGE);
24167 let region_count = regions.len();
24168 let _return = _function(
24169 command_buffer as _,
24170 src_buffer as _,
24171 dst_buffer as _,
24172 region_count as _,
24173 regions.as_ptr() as _,
24174 );
24175 ()
24176 }
24177 #[inline]
24178 #[track_caller]
24179 #[doc(alias = "vkCmdCopyImage")]
24181 pub unsafe fn cmd_copy_image(
24182 &self,
24183 command_buffer: crate::vk1_0::CommandBuffer,
24184 src_image: crate::vk1_0::Image,
24185 src_image_layout: crate::vk1_0::ImageLayout,
24186 dst_image: crate::vk1_0::Image,
24187 dst_image_layout: crate::vk1_0::ImageLayout,
24188 regions: &[crate::vk1_0::ImageCopyBuilder],
24189 ) -> () {
24190 let _function = self.cmd_copy_image.expect(crate::NOT_LOADED_MESSAGE);
24191 let region_count = regions.len();
24192 let _return = _function(
24193 command_buffer as _,
24194 src_image as _,
24195 src_image_layout as _,
24196 dst_image as _,
24197 dst_image_layout as _,
24198 region_count as _,
24199 regions.as_ptr() as _,
24200 );
24201 ()
24202 }
24203 #[inline]
24204 #[track_caller]
24205 #[doc(alias = "vkCmdBlitImage")]
24207 pub unsafe fn cmd_blit_image(
24208 &self,
24209 command_buffer: crate::vk1_0::CommandBuffer,
24210 src_image: crate::vk1_0::Image,
24211 src_image_layout: crate::vk1_0::ImageLayout,
24212 dst_image: crate::vk1_0::Image,
24213 dst_image_layout: crate::vk1_0::ImageLayout,
24214 regions: &[crate::vk1_0::ImageBlitBuilder],
24215 filter: crate::vk1_0::Filter,
24216 ) -> () {
24217 let _function = self.cmd_blit_image.expect(crate::NOT_LOADED_MESSAGE);
24218 let region_count = regions.len();
24219 let _return = _function(
24220 command_buffer as _,
24221 src_image as _,
24222 src_image_layout as _,
24223 dst_image as _,
24224 dst_image_layout as _,
24225 region_count as _,
24226 regions.as_ptr() as _,
24227 filter as _,
24228 );
24229 ()
24230 }
24231 #[inline]
24232 #[track_caller]
24233 #[doc(alias = "vkCmdCopyBufferToImage")]
24235 pub unsafe fn cmd_copy_buffer_to_image(
24236 &self,
24237 command_buffer: crate::vk1_0::CommandBuffer,
24238 src_buffer: crate::vk1_0::Buffer,
24239 dst_image: crate::vk1_0::Image,
24240 dst_image_layout: crate::vk1_0::ImageLayout,
24241 regions: &[crate::vk1_0::BufferImageCopyBuilder],
24242 ) -> () {
24243 let _function = self.cmd_copy_buffer_to_image.expect(crate::NOT_LOADED_MESSAGE);
24244 let region_count = regions.len();
24245 let _return = _function(
24246 command_buffer as _,
24247 src_buffer as _,
24248 dst_image as _,
24249 dst_image_layout as _,
24250 region_count as _,
24251 regions.as_ptr() as _,
24252 );
24253 ()
24254 }
24255 #[inline]
24256 #[track_caller]
24257 #[doc(alias = "vkCmdCopyImageToBuffer")]
24259 pub unsafe fn cmd_copy_image_to_buffer(
24260 &self,
24261 command_buffer: crate::vk1_0::CommandBuffer,
24262 src_image: crate::vk1_0::Image,
24263 src_image_layout: crate::vk1_0::ImageLayout,
24264 dst_buffer: crate::vk1_0::Buffer,
24265 regions: &[crate::vk1_0::BufferImageCopyBuilder],
24266 ) -> () {
24267 let _function = self.cmd_copy_image_to_buffer.expect(crate::NOT_LOADED_MESSAGE);
24268 let region_count = regions.len();
24269 let _return = _function(
24270 command_buffer as _,
24271 src_image as _,
24272 src_image_layout as _,
24273 dst_buffer as _,
24274 region_count as _,
24275 regions.as_ptr() as _,
24276 );
24277 ()
24278 }
24279 #[inline]
24280 #[track_caller]
24281 #[doc(alias = "vkCmdUpdateBuffer")]
24283 pub unsafe fn cmd_update_buffer(
24284 &self,
24285 command_buffer: crate::vk1_0::CommandBuffer,
24286 dst_buffer: crate::vk1_0::Buffer,
24287 dst_offset: crate::vk1_0::DeviceSize,
24288 data_size: crate::vk1_0::DeviceSize,
24289 data: *const std::ffi::c_void,
24290 ) -> () {
24291 let _function = self.cmd_update_buffer.expect(crate::NOT_LOADED_MESSAGE);
24292 let _return = _function(
24293 command_buffer as _,
24294 dst_buffer as _,
24295 dst_offset as _,
24296 data_size,
24297 data,
24298 );
24299 ()
24300 }
24301 #[inline]
24302 #[track_caller]
24303 #[doc(alias = "vkCmdFillBuffer")]
24305 pub unsafe fn cmd_fill_buffer(
24306 &self,
24307 command_buffer: crate::vk1_0::CommandBuffer,
24308 dst_buffer: crate::vk1_0::Buffer,
24309 dst_offset: crate::vk1_0::DeviceSize,
24310 size: crate::vk1_0::DeviceSize,
24311 data: u32,
24312 ) -> () {
24313 let _function = self.cmd_fill_buffer.expect(crate::NOT_LOADED_MESSAGE);
24314 let _return = _function(
24315 command_buffer as _,
24316 dst_buffer as _,
24317 dst_offset as _,
24318 size as _,
24319 data as _,
24320 );
24321 ()
24322 }
24323 #[inline]
24324 #[track_caller]
24325 #[doc(alias = "vkCmdClearColorImage")]
24327 pub unsafe fn cmd_clear_color_image(
24328 &self,
24329 command_buffer: crate::vk1_0::CommandBuffer,
24330 image: crate::vk1_0::Image,
24331 image_layout: crate::vk1_0::ImageLayout,
24332 color: &crate::vk1_0::ClearColorValue,
24333 ranges: &[crate::vk1_0::ImageSubresourceRangeBuilder],
24334 ) -> () {
24335 let _function = self.cmd_clear_color_image.expect(crate::NOT_LOADED_MESSAGE);
24336 let range_count = ranges.len();
24337 let _return = _function(
24338 command_buffer as _,
24339 image as _,
24340 image_layout as _,
24341 color as _,
24342 range_count as _,
24343 ranges.as_ptr() as _,
24344 );
24345 ()
24346 }
24347 #[inline]
24348 #[track_caller]
24349 #[doc(alias = "vkCmdClearDepthStencilImage")]
24351 pub unsafe fn cmd_clear_depth_stencil_image(
24352 &self,
24353 command_buffer: crate::vk1_0::CommandBuffer,
24354 image: crate::vk1_0::Image,
24355 image_layout: crate::vk1_0::ImageLayout,
24356 depth_stencil: &crate::vk1_0::ClearDepthStencilValue,
24357 ranges: &[crate::vk1_0::ImageSubresourceRangeBuilder],
24358 ) -> () {
24359 let _function = self
24360 .cmd_clear_depth_stencil_image
24361 .expect(crate::NOT_LOADED_MESSAGE);
24362 let range_count = ranges.len();
24363 let _return = _function(
24364 command_buffer as _,
24365 image as _,
24366 image_layout as _,
24367 depth_stencil as _,
24368 range_count as _,
24369 ranges.as_ptr() as _,
24370 );
24371 ()
24372 }
24373 #[inline]
24374 #[track_caller]
24375 #[doc(alias = "vkCmdClearAttachments")]
24377 pub unsafe fn cmd_clear_attachments(
24378 &self,
24379 command_buffer: crate::vk1_0::CommandBuffer,
24380 attachments: &[crate::vk1_0::ClearAttachmentBuilder],
24381 rects: &[crate::vk1_0::ClearRectBuilder],
24382 ) -> () {
24383 let _function = self.cmd_clear_attachments.expect(crate::NOT_LOADED_MESSAGE);
24384 let attachment_count = attachments.len();
24385 let rect_count = rects.len();
24386 let _return = _function(
24387 command_buffer as _,
24388 attachment_count as _,
24389 attachments.as_ptr() as _,
24390 rect_count as _,
24391 rects.as_ptr() as _,
24392 );
24393 ()
24394 }
24395 #[inline]
24396 #[track_caller]
24397 #[doc(alias = "vkCmdResolveImage")]
24399 pub unsafe fn cmd_resolve_image(
24400 &self,
24401 command_buffer: crate::vk1_0::CommandBuffer,
24402 src_image: crate::vk1_0::Image,
24403 src_image_layout: crate::vk1_0::ImageLayout,
24404 dst_image: crate::vk1_0::Image,
24405 dst_image_layout: crate::vk1_0::ImageLayout,
24406 regions: &[crate::vk1_0::ImageResolveBuilder],
24407 ) -> () {
24408 let _function = self.cmd_resolve_image.expect(crate::NOT_LOADED_MESSAGE);
24409 let region_count = regions.len();
24410 let _return = _function(
24411 command_buffer as _,
24412 src_image as _,
24413 src_image_layout as _,
24414 dst_image as _,
24415 dst_image_layout as _,
24416 region_count as _,
24417 regions.as_ptr() as _,
24418 );
24419 ()
24420 }
24421 #[inline]
24422 #[track_caller]
24423 #[doc(alias = "vkCmdSetEvent")]
24425 pub unsafe fn cmd_set_event(
24426 &self,
24427 command_buffer: crate::vk1_0::CommandBuffer,
24428 event: crate::vk1_0::Event,
24429 stage_mask: crate::vk1_0::PipelineStageFlags,
24430 ) -> () {
24431 let _function = self.cmd_set_event.expect(crate::NOT_LOADED_MESSAGE);
24432 let _return = _function(command_buffer as _, event as _, stage_mask as _);
24433 ()
24434 }
24435 #[inline]
24436 #[track_caller]
24437 #[doc(alias = "vkCmdResetEvent")]
24439 pub unsafe fn cmd_reset_event(
24440 &self,
24441 command_buffer: crate::vk1_0::CommandBuffer,
24442 event: crate::vk1_0::Event,
24443 stage_mask: crate::vk1_0::PipelineStageFlags,
24444 ) -> () {
24445 let _function = self.cmd_reset_event.expect(crate::NOT_LOADED_MESSAGE);
24446 let _return = _function(command_buffer as _, event as _, stage_mask as _);
24447 ()
24448 }
24449 #[inline]
24450 #[track_caller]
24451 #[doc(alias = "vkCmdWaitEvents")]
24453 pub unsafe fn cmd_wait_events(
24454 &self,
24455 command_buffer: crate::vk1_0::CommandBuffer,
24456 events: &[crate::vk1_0::Event],
24457 src_stage_mask: crate::vk1_0::PipelineStageFlags,
24458 dst_stage_mask: crate::vk1_0::PipelineStageFlags,
24459 memory_barriers: &[crate::vk1_0::MemoryBarrierBuilder],
24460 buffer_memory_barriers: &[crate::vk1_0::BufferMemoryBarrierBuilder],
24461 image_memory_barriers: &[crate::vk1_0::ImageMemoryBarrierBuilder],
24462 ) -> () {
24463 let _function = self.cmd_wait_events.expect(crate::NOT_LOADED_MESSAGE);
24464 let event_count = events.len();
24465 let memory_barrier_count = memory_barriers.len();
24466 let buffer_memory_barrier_count = buffer_memory_barriers.len();
24467 let image_memory_barrier_count = image_memory_barriers.len();
24468 let _return = _function(
24469 command_buffer as _,
24470 event_count as _,
24471 events.as_ptr() as _,
24472 src_stage_mask as _,
24473 dst_stage_mask as _,
24474 memory_barrier_count as _,
24475 memory_barriers.as_ptr() as _,
24476 buffer_memory_barrier_count as _,
24477 buffer_memory_barriers.as_ptr() as _,
24478 image_memory_barrier_count as _,
24479 image_memory_barriers.as_ptr() as _,
24480 );
24481 ()
24482 }
24483 #[inline]
24484 #[track_caller]
24485 #[doc(alias = "vkCmdPipelineBarrier")]
24487 pub unsafe fn cmd_pipeline_barrier(
24488 &self,
24489 command_buffer: crate::vk1_0::CommandBuffer,
24490 src_stage_mask: crate::vk1_0::PipelineStageFlags,
24491 dst_stage_mask: crate::vk1_0::PipelineStageFlags,
24492 dependency_flags: crate::vk1_0::DependencyFlags,
24493 memory_barriers: &[crate::vk1_0::MemoryBarrierBuilder],
24494 buffer_memory_barriers: &[crate::vk1_0::BufferMemoryBarrierBuilder],
24495 image_memory_barriers: &[crate::vk1_0::ImageMemoryBarrierBuilder],
24496 ) -> () {
24497 let _function = self.cmd_pipeline_barrier.expect(crate::NOT_LOADED_MESSAGE);
24498 let memory_barrier_count = memory_barriers.len();
24499 let buffer_memory_barrier_count = buffer_memory_barriers.len();
24500 let image_memory_barrier_count = image_memory_barriers.len();
24501 let _return = _function(
24502 command_buffer as _,
24503 src_stage_mask as _,
24504 dst_stage_mask as _,
24505 dependency_flags as _,
24506 memory_barrier_count as _,
24507 memory_barriers.as_ptr() as _,
24508 buffer_memory_barrier_count as _,
24509 buffer_memory_barriers.as_ptr() as _,
24510 image_memory_barrier_count as _,
24511 image_memory_barriers.as_ptr() as _,
24512 );
24513 ()
24514 }
24515 #[inline]
24516 #[track_caller]
24517 #[doc(alias = "vkCmdBeginQuery")]
24519 pub unsafe fn cmd_begin_query(
24520 &self,
24521 command_buffer: crate::vk1_0::CommandBuffer,
24522 query_pool: crate::vk1_0::QueryPool,
24523 query: u32,
24524 flags: crate::vk1_0::QueryControlFlags,
24525 ) -> () {
24526 let _function = self.cmd_begin_query.expect(crate::NOT_LOADED_MESSAGE);
24527 let _return = _function(
24528 command_buffer as _,
24529 query_pool as _,
24530 query as _,
24531 flags as _,
24532 );
24533 ()
24534 }
24535 #[inline]
24536 #[track_caller]
24537 #[doc(alias = "vkCmdEndQuery")]
24539 pub unsafe fn cmd_end_query(
24540 &self,
24541 command_buffer: crate::vk1_0::CommandBuffer,
24542 query_pool: crate::vk1_0::QueryPool,
24543 query: u32,
24544 ) -> () {
24545 let _function = self.cmd_end_query.expect(crate::NOT_LOADED_MESSAGE);
24546 let _return = _function(command_buffer as _, query_pool as _, query as _);
24547 ()
24548 }
24549 #[inline]
24550 #[track_caller]
24551 #[doc(alias = "vkCmdResetQueryPool")]
24553 pub unsafe fn cmd_reset_query_pool(
24554 &self,
24555 command_buffer: crate::vk1_0::CommandBuffer,
24556 query_pool: crate::vk1_0::QueryPool,
24557 first_query: u32,
24558 query_count: u32,
24559 ) -> () {
24560 let _function = self.cmd_reset_query_pool.expect(crate::NOT_LOADED_MESSAGE);
24561 let _return = _function(
24562 command_buffer as _,
24563 query_pool as _,
24564 first_query as _,
24565 query_count as _,
24566 );
24567 ()
24568 }
24569 #[inline]
24570 #[track_caller]
24571 #[doc(alias = "vkCmdWriteTimestamp")]
24573 pub unsafe fn cmd_write_timestamp(
24574 &self,
24575 command_buffer: crate::vk1_0::CommandBuffer,
24576 pipeline_stage: crate::vk1_0::PipelineStageFlagBits,
24577 query_pool: crate::vk1_0::QueryPool,
24578 query: u32,
24579 ) -> () {
24580 let _function = self.cmd_write_timestamp.expect(crate::NOT_LOADED_MESSAGE);
24581 let _return = _function(
24582 command_buffer as _,
24583 pipeline_stage as _,
24584 query_pool as _,
24585 query as _,
24586 );
24587 ()
24588 }
24589 #[inline]
24590 #[track_caller]
24591 #[doc(alias = "vkCmdCopyQueryPoolResults")]
24593 pub unsafe fn cmd_copy_query_pool_results(
24594 &self,
24595 command_buffer: crate::vk1_0::CommandBuffer,
24596 query_pool: crate::vk1_0::QueryPool,
24597 first_query: u32,
24598 query_count: u32,
24599 dst_buffer: crate::vk1_0::Buffer,
24600 dst_offset: crate::vk1_0::DeviceSize,
24601 stride: crate::vk1_0::DeviceSize,
24602 flags: crate::vk1_0::QueryResultFlags,
24603 ) -> () {
24604 let _function = self
24605 .cmd_copy_query_pool_results
24606 .expect(crate::NOT_LOADED_MESSAGE);
24607 let _return = _function(
24608 command_buffer as _,
24609 query_pool as _,
24610 first_query as _,
24611 query_count as _,
24612 dst_buffer as _,
24613 dst_offset as _,
24614 stride as _,
24615 flags as _,
24616 );
24617 ()
24618 }
24619 #[inline]
24620 #[track_caller]
24621 #[doc(alias = "vkCmdPushConstants")]
24623 pub unsafe fn cmd_push_constants(
24624 &self,
24625 command_buffer: crate::vk1_0::CommandBuffer,
24626 layout: crate::vk1_0::PipelineLayout,
24627 stage_flags: crate::vk1_0::ShaderStageFlags,
24628 offset: u32,
24629 size: u32,
24630 values: *const std::ffi::c_void,
24631 ) -> () {
24632 let _function = self.cmd_push_constants.expect(crate::NOT_LOADED_MESSAGE);
24633 let _return = _function(
24634 command_buffer as _,
24635 layout as _,
24636 stage_flags as _,
24637 offset as _,
24638 size,
24639 values,
24640 );
24641 ()
24642 }
24643 #[inline]
24644 #[track_caller]
24645 #[doc(alias = "vkCmdBeginRenderPass")]
24647 pub unsafe fn cmd_begin_render_pass(
24648 &self,
24649 command_buffer: crate::vk1_0::CommandBuffer,
24650 render_pass_begin: &crate::vk1_0::RenderPassBeginInfo,
24651 contents: crate::vk1_0::SubpassContents,
24652 ) -> () {
24653 let _function = self.cmd_begin_render_pass.expect(crate::NOT_LOADED_MESSAGE);
24654 let _return = _function(
24655 command_buffer as _,
24656 render_pass_begin as _,
24657 contents as _,
24658 );
24659 ()
24660 }
24661 #[inline]
24662 #[track_caller]
24663 #[doc(alias = "vkCmdNextSubpass")]
24665 pub unsafe fn cmd_next_subpass(
24666 &self,
24667 command_buffer: crate::vk1_0::CommandBuffer,
24668 contents: crate::vk1_0::SubpassContents,
24669 ) -> () {
24670 let _function = self.cmd_next_subpass.expect(crate::NOT_LOADED_MESSAGE);
24671 let _return = _function(command_buffer as _, contents as _);
24672 ()
24673 }
24674 #[inline]
24675 #[track_caller]
24676 #[doc(alias = "vkCmdEndRenderPass")]
24678 pub unsafe fn cmd_end_render_pass(
24679 &self,
24680 command_buffer: crate::vk1_0::CommandBuffer,
24681 ) -> () {
24682 let _function = self.cmd_end_render_pass.expect(crate::NOT_LOADED_MESSAGE);
24683 let _return = _function(command_buffer as _);
24684 ()
24685 }
24686 #[inline]
24687 #[track_caller]
24688 #[doc(alias = "vkCmdExecuteCommands")]
24690 pub unsafe fn cmd_execute_commands(
24691 &self,
24692 command_buffer: crate::vk1_0::CommandBuffer,
24693 command_buffers: &[crate::vk1_0::CommandBuffer],
24694 ) -> () {
24695 let _function = self.cmd_execute_commands.expect(crate::NOT_LOADED_MESSAGE);
24696 let command_buffer_count = command_buffers.len();
24697 let _return = _function(
24698 command_buffer as _,
24699 command_buffer_count as _,
24700 command_buffers.as_ptr() as _,
24701 );
24702 ()
24703 }
24704}