dacite/core/
mod.rs

1// Copyright (c) 2017, Dennis Hamester <dennis.hamester@startmail.com>
2//
3// Permission to use, copy, modify, and/or distribute this software for any
4// purpose with or without fee is hereby granted, provided that the above
5// copyright notice and this permission notice appear in all copies.
6//
7// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
8// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
9// FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
10// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
11// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
12// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
13// PERFORMANCE OF THIS SOFTWARE.
14
15//! Vulkan core specification
16
17#[macro_use]
18mod extension_structs;
19
20mod buffer;
21mod buffer_view;
22mod command_buffer;
23mod command_pool;
24mod descriptor_pool;
25mod descriptor_set;
26mod descriptor_set_layout;
27mod device;
28mod device_memory;
29mod event;
30mod fence;
31mod framebuffer;
32mod image;
33mod image_view;
34mod instance;
35mod physical_device;
36mod pipeline;
37mod pipeline_cache;
38mod pipeline_layout;
39mod query_pool;
40mod queue;
41mod render_pass;
42mod sampler;
43mod semaphore;
44mod shader_module;
45
46pub(crate) mod allocator_helper;
47
48use amd_rasterization_order;
49use ext_debug_report;
50use ext_validation_flags;
51use khr_get_physical_device_properties2;
52use libc::{c_char, c_void};
53use nv_dedicated_allocation;
54use nv_external_memory;
55use nv_external_memory_win32;
56use nv_win32_keyed_mutex;
57use std::cmp;
58use std::collections::{HashMap, HashSet};
59use std::ffi::{CStr, CString};
60use std::fmt;
61use std::mem;
62use std::ptr;
63use std::slice;
64use std::time::Duration;
65use utils;
66use vks;
67
68pub use self::buffer::{Buffer, FromNativeBufferParameters};
69pub use self::buffer_view::{BufferView, FromNativeBufferViewParameters};
70pub use self::command_buffer::{CommandBuffer, FromNativeCommandBufferParameters};
71pub use self::command_pool::{CommandPool, FromNativeCommandPoolParameters};
72pub use self::descriptor_pool::{DescriptorPool, FromNativeDescriptorPoolParameters};
73pub use self::descriptor_set::DescriptorSet;
74pub use self::descriptor_set_layout::{DescriptorSetLayout, FromNativeDescriptorSetLayoutParameters};
75pub use self::device::Device;
76pub use self::device_memory::{DeviceMemory, MappedMemory, FromNativeDeviceMemoryParameters};
77pub use self::event::{Event, FromNativeEventParameters};
78pub use self::fence::{Fence, FromNativeFenceParameters};
79pub use self::framebuffer::{Framebuffer, FromNativeFramebufferParameters};
80pub use self::image::{Image, FromNativeImageParameters};
81pub use self::image_view::{ImageView, FromNativeImageViewParameters};
82pub use self::instance::{EarlyInstanceError, Instance};
83pub use self::physical_device::PhysicalDevice;
84pub use self::pipeline::{Pipeline, FromNativePipelineParameters};
85pub use self::pipeline_cache::{PipelineCache, FromNativePipelineCacheParameters};
86pub use self::pipeline_layout::{PipelineLayout, FromNativePipelineLayoutParameters};
87pub use self::query_pool::{QueryPool, FromNativeQueryPoolParameters};
88pub use self::queue::Queue;
89pub use self::render_pass::{RenderPass, FromNativeRenderPassParameters};
90pub use self::sampler::{Sampler, FromNativeSamplerParameters};
91pub use self::semaphore::{Semaphore, FromNativeSemaphoreParameters};
92pub use self::shader_module::{ShaderModule, FromNativeShaderModuleParameters};
93
94dacite_bitflags! {
95    /// See [`VkInstanceCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkInstanceCreateFlags)
96    pub struct InstanceCreateFlags: vks::core::VkInstanceCreateFlags;
97    pub enum InstanceCreateFlagBits: vks::core::VkInstanceCreateFlagBits;
98    max_enum: vks::core::VK_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM;
99
100    flags {}
101    no_bits {}
102}
103
104dacite_bitflags! {
105    /// See [`VkFormatFeatureFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFormatFeatureFlagBits)
106    pub struct FormatFeatureFlags: vks::core::VkFormatFeatureFlags;
107    pub enum FormatFeatureFlagBits: vks::core::VkFormatFeatureFlagBits;
108    max_enum: vks::core::VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM;
109
110    flags {
111        const SAMPLED_IMAGE [SampledImage] = vks::core::VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
112        const STORAGE_IMAGE [StorageImage] = vks::core::VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
113        const STORAGE_IMAGE_ATOMIC [StorageImageAtomic] = vks::core::VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT;
114        const UNIFORM_TEXEL_BUFFER [UniformTexelBuffer] = vks::core::VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
115        const STORAGE_TEXEL_BUFFER [StorageTexelBuffer] = vks::core::VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
116        const STORAGE_TEXEL_BUFFER_ATOMIC [StorageTexelBufferAtomic] = vks::core::VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
117        const VERTEX_BUFFER [VertexBuffer] = vks::core::VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
118        const COLOR_ATTACHMENT [ColorAttachment] = vks::core::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
119        const COLOR_ATTACHMENT_BLEND [ColorAttachmentBlend] = vks::core::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
120        const DEPTH_STENCIL_ATTACHMENT [DepthStencilAttachment] = vks::core::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
121        const BLIT_SRC [BlitSrc] = vks::core::VK_FORMAT_FEATURE_BLIT_SRC_BIT;
122        const BLIT_DST [BlitDst] = vks::core::VK_FORMAT_FEATURE_BLIT_DST_BIT;
123        const SAMPLED_IMAGE_FILTER_LINEAR [SampledImageFilterLinear] = vks::core::VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
124
125        // /// See extension [`VK_IMG_filter_cubic`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_filter_cubic)
126        const SAMPLED_IMAGE_FILTER_CUBIC_BIT [SampledImageFilterCubicImg] = vks::core::VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG;
127    }
128
129    no_bits {}
130}
131
132dacite_bitflags! {
133    /// See [`VkImageUsageFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageUsageFlagBits)
134    pub struct ImageUsageFlags: vks::core::VkImageUsageFlags;
135    pub enum ImageUsageFlagBits: vks::core::VkImageUsageFlagBits;
136    max_enum: vks::core::VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM;
137
138    flags {
139        const TRANSFER_SRC [TransferSrc] = vks::core::VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
140        const TRANSFER_DST [TransferDst] = vks::core::VK_IMAGE_USAGE_TRANSFER_DST_BIT;
141        const SAMPLED [Sampled] = vks::core::VK_IMAGE_USAGE_SAMPLED_BIT;
142        const STORAGE [Storage] = vks::core::VK_IMAGE_USAGE_STORAGE_BIT;
143        const COLOR_ATTACHMENT [ColorAttachment] = vks::core::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
144        const DEPTH_STENCIL_ATTACHMENT [DepthStencilAttachment] = vks::core::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
145        const TRANSIENT_ATTACHMENT [TransientAttachment] = vks::core::VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
146        const INPUT_ATTACHMENT [InputAttachment] = vks::core::VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
147    }
148
149    no_bits {}
150}
151
152dacite_bitflags! {
153    /// See [`VkImageCreateFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageCreateFlagBits)
154    pub struct ImageCreateFlags: vks::core::VkImageCreateFlags;
155    pub enum ImageCreateFlagBits: vks::core::VkImageCreateFlagBits;
156    max_enum: vks::core::VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM;
157
158    flags {
159        const SPARSE_BINDING [SparseBinding] = vks::core::VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
160        const SPARSE_RESIDENCY [SparseResidency] = vks::core::VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT;
161        const SPARSE_ALIASED [SparseAliased] = vks::core::VK_IMAGE_CREATE_SPARSE_ALIASED_BIT;
162        const MUTABLE_FORMAT [MutableFormat] = vks::core::VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
163        const CUBE_COMPATIBLE [CubeCompatible] = vks::core::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
164    }
165
166    no_bits {}
167}
168
169dacite_bitflags! {
170    /// See [`VkSampleCountFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSampleCountFlagBits)
171    pub struct SampleCountFlags: vks::core::VkSampleCountFlags;
172    pub enum SampleCountFlagBits: vks::core::VkSampleCountFlagBits;
173    max_enum: vks::core::VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM;
174
175    flags {
176        const SAMPLE_COUNT_1 [SampleCount1] = vks::core::VK_SAMPLE_COUNT_1_BIT;
177        const SAMPLE_COUNT_2 [SampleCount2] = vks::core::VK_SAMPLE_COUNT_2_BIT;
178        const SAMPLE_COUNT_4 [SampleCount4] = vks::core::VK_SAMPLE_COUNT_4_BIT;
179        const SAMPLE_COUNT_8 [SampleCount8] = vks::core::VK_SAMPLE_COUNT_8_BIT;
180        const SAMPLE_COUNT_16 [SampleCount16] = vks::core::VK_SAMPLE_COUNT_16_BIT;
181        const SAMPLE_COUNT_32 [SampleCount32] = vks::core::VK_SAMPLE_COUNT_32_BIT;
182        const SAMPLE_COUNT_64 [SampleCount64] = vks::core::VK_SAMPLE_COUNT_64_BIT;
183    }
184
185    no_bits {}
186}
187
188dacite_bitflags! {
189    /// See [`VkQueueFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkQueueFlagBits)
190    pub struct QueueFlags: vks::core::VkQueueFlags;
191    pub enum QueueFlagBits: vks::core::VkQueueFlagBits;
192    max_enum: vks::core::VK_QUEUE_FLAG_BITS_MAX_ENUM;
193
194    flags {
195        const GRAPHICS [Graphics] = vks::core::VK_QUEUE_GRAPHICS_BIT;
196        const COMPUTE [Compute] = vks::core::VK_QUEUE_COMPUTE_BIT;
197        const TRANSFER [Transfer] = vks::core::VK_QUEUE_TRANSFER_BIT;
198        const SPARSE_BINDING [SparseBinding] = vks::core::VK_QUEUE_SPARSE_BINDING_BIT;
199    }
200
201    no_bits {}
202}
203
204dacite_bitflags! {
205    /// See [`VkMemoryPropertyFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryPropertyFlagBits)
206    pub struct MemoryPropertyFlags: vks::core::VkMemoryPropertyFlags;
207    pub enum MemoryPropertyFlagBits: vks::core::VkMemoryPropertyFlagBits;
208    max_enum: vks::core::VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM;
209
210    flags {
211        const DEVICE_LOCAL [DeviceLocal] = vks::core::VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
212        const HOST_VISIBLE [HostVisible] = vks::core::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
213        const HOST_COHERENT [HostCoherent] = vks::core::VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
214        const HOST_CACHED [HostCached] = vks::core::VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
215        const LAZILY_ALLOCATED [LazilyAllocated] = vks::core::VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
216    }
217
218    no_bits {}
219}
220
221dacite_bitflags! {
222    /// See [`VkMemoryHeapFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryHeapFlagBits)
223    pub struct MemoryHeapFlags: vks::core::VkMemoryHeapFlags;
224    pub enum MemoryHeapFlagBits: vks::core::VkMemoryHeapFlagBits;
225    max_enum: vks::core::VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM;
226
227    flags {
228        const DEVICE_LOCAL [DeviceLocal] = vks::core::VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
229    }
230
231    no_bits {}
232}
233
234dacite_bitflags! {
235    /// See [`VkDeviceCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDeviceCreateFlags)
236    pub struct DeviceCreateFlags: vks::core::VkDeviceCreateFlags;
237    pub enum DeviceCreateFlagBits: vks::core::VkDeviceCreateFlagBits;
238    max_enum: vks::core::VK_DEVICE_CREATE_FLAG_BITS_MAX_ENUM;
239
240    flags {}
241    no_bits {}
242}
243
244dacite_bitflags! {
245    /// See [`VkDeviceQueueCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDeviceQueueCreateFlags)
246    pub struct DeviceQueueCreateFlags: vks::core::VkDeviceQueueCreateFlags;
247    pub enum DeviceQueueCreateFlagBits: vks::core::VkDeviceQueueCreateFlagBits;
248    max_enum: vks::core::VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM;
249
250    flags {}
251    no_bits {}
252}
253
254dacite_bitflags! {
255    /// See [`VkPipelineStageFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineStageFlagBits)
256    pub struct PipelineStageFlags: vks::core::VkPipelineStageFlags;
257    pub enum PipelineStageFlagBits: vks::core::VkPipelineStageFlagBits;
258    max_enum: vks::core::VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM;
259
260    flags {
261        const TOP_OF_PIPE [TopOfPipe] = vks::core::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
262        const DRAW_INDIRECT [DrawIndirect] = vks::core::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
263        const VERTEX_INPUT [VertexInput] = vks::core::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
264        const VERTEX_SHADER [VertexShader] = vks::core::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
265        const TESSELLATION_CONTROL_SHADER [TessellationControlShader] = vks::core::VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
266        const TESSELLATION_EVALUATION_SHADER [TessellationEvaluationShader] = vks::core::VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
267        const GEOMETRY_SHADER [GeometryShader] = vks::core::VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
268        const FRAGMENT_SHADER [FragmentShader] = vks::core::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
269        const EARLY_FRAGMENT_TESTS [EarlyFragmentTests] = vks::core::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
270        const LATE_FRAGMENT_TESTS [LateFragmentTests] = vks::core::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
271        const COLOR_ATTACHMENT_OUTPUT [ColorAttachmentOutput] = vks::core::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
272        const COMPUTE_SHADER [ComputeShader] = vks::core::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
273        const TRANSFER [Transfer] = vks::core::VK_PIPELINE_STAGE_TRANSFER_BIT;
274        const BOTTOM_OF_PIPE [BottomOfPipe] = vks::core::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
275        const HOST [Host] = vks::core::VK_PIPELINE_STAGE_HOST_BIT;
276        const ALL_GRAPHICS [AllGraphics] = vks::core::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
277        const ALL_COMMANDS [AllCommands] = vks::core::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
278    }
279
280    no_bits {}
281}
282
283dacite_bitflags! {
284    /// See [`VkMemoryMapFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryMapFlags)
285    pub struct MemoryMapFlags: vks::core::VkMemoryMapFlags;
286    pub enum MemoryMapFlagBits: vks::core::VkMemoryMapFlagBits;
287    max_enum: vks::core::VK_MEMORY_MAP_FLAG_BITS_MAX_ENUM;
288
289    flags {}
290    no_bits {}
291}
292
293dacite_bitflags! {
294    /// See [`VkImageAspectFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageAspectFlagBits)
295    pub struct ImageAspectFlags: vks::core::VkImageAspectFlags;
296    pub enum ImageAspectFlagBits: vks::core::VkImageAspectFlagBits;
297    max_enum: vks::core::VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM;
298
299    flags {
300        const COLOR [Color] = vks::core::VK_IMAGE_ASPECT_COLOR_BIT;
301        const DEPTH [Depth] = vks::core::VK_IMAGE_ASPECT_DEPTH_BIT;
302        const STENCIL [Stencil] = vks::core::VK_IMAGE_ASPECT_STENCIL_BIT;
303        const METADATA [Metadata] = vks::core::VK_IMAGE_ASPECT_METADATA_BIT;
304    }
305
306    no_bits {}
307}
308
309dacite_bitflags! {
310    /// See [`VkSparseImageFormatFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseImageFormatFlagBits)
311    pub struct SparseImageFormatFlags: vks::core::VkSparseImageFormatFlags;
312    pub enum SparseImageFormatFlagBits: vks::core::VkSparseImageFormatFlagBits;
313    max_enum: vks::core::VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM;
314
315    flags {
316        const SINGLE_MIPTAIL [SingleMiptail] = vks::core::VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT;
317        const ALIGNED_MIP_SIZE [AlignedMipSize] = vks::core::VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT;
318        const NONSTANDARD_BLOCK_SIZE [NonstandardBlockSize] = vks::core::VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT;
319    }
320
321    no_bits {}
322}
323
324dacite_bitflags! {
325    /// See [`VkSparseMemoryBindFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseMemoryBindFlagBits)
326    pub struct SparseMemoryBindFlags: vks::core::VkSparseMemoryBindFlags;
327    pub enum SparseMemoryBindFlagBits: vks::core::VkSparseMemoryBindFlagBits;
328    max_enum: vks::core::VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM;
329
330    flags {
331        const METADATA [Metadata] = vks::core::VK_SPARSE_MEMORY_BIND_METADATA_BIT;
332    }
333
334    no_bits {}
335}
336
337dacite_bitflags! {
338    /// See [`VkFenceCreateFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFenceCreateFlagBits)
339    pub struct FenceCreateFlags: vks::core::VkFenceCreateFlags;
340    pub enum FenceCreateFlagBits: vks::core::VkFenceCreateFlagBits;
341    max_enum: vks::core::VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM;
342
343    flags {
344        const SIGNALED [Signaled] = vks::core::VK_FENCE_CREATE_SIGNALED_BIT;
345    }
346
347    no_bits {}
348}
349
350dacite_bitflags! {
351    /// See [`VkSemaphoreCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSemaphoreCreateFlags)
352    pub struct SemaphoreCreateFlags: vks::core::VkSemaphoreCreateFlags;
353    pub enum SemaphoreCreateFlagBits: vks::core::VkSemaphoreCreateFlagBits;
354    max_enum: vks::core::VK_SEMAPHORE_CREATE_FLAG_BITS_MAX_ENUM;
355
356    flags {}
357    no_bits {}
358}
359
360dacite_bitflags! {
361    /// See [`VkEventCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkEventCreateFlags)
362    pub struct EventCreateFlags: vks::core::VkEventCreateFlags;
363    pub enum EventCreateFlagBits: vks::core::VkEventCreateFlagBits;
364    max_enum: vks::core::VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM;
365
366    flags {}
367    no_bits {}
368}
369
370dacite_bitflags! {
371    /// See [`VkQueryPoolCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkQueryPoolCreateFlags)
372    pub struct QueryPoolCreateFlags: vks::core::VkQueryPoolCreateFlags;
373    pub enum QueryPoolCreateFlagBits: vks::core::VkQueryPoolCreateFlagBits;
374    max_enum: vks::core::VK_QUERY_POOL_CREATE_FLAG_BITS_MAX_ENUM;
375
376    flags {}
377    no_bits {}
378}
379
380dacite_bitflags! {
381    /// See [`VkQueryPipelineStatisticFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkQueryPipelineStatisticFlagBits)
382    pub struct QueryPipelineStatisticFlags: vks::core::VkQueryPipelineStatisticFlags;
383    pub enum QueryPipelineStatisticFlagBits: vks::core::VkQueryPipelineStatisticFlagBits;
384    max_enum: vks::core::VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM;
385
386    flags {
387        const INPUT_ASSEMBLY_VERTICES [InputAssemblyVertices] = vks::core::VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT;
388        const INPUT_ASSEMBLY_PRIMITIVES [InputAssemblyPrimitives] = vks::core::VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT;
389        const VERTEX_SHADER_INVOCATIONS [VertexShaderInvocations] = vks::core::VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT;
390        const GEOMETRY_SHADER_INVOCATIONS [GeometryShaderInvocations] = vks::core::VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT;
391        const GEOMETRY_SHADER_PRIMITIVES [GeometryShaderPrimitives] = vks::core::VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT;
392        const CLIPPING_INVOCATIONS [ClippingInvocations] = vks::core::VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT;
393        const CLIPPING_PRIMITIVES [ClippingPrimitives] = vks::core::VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT;
394        const FRAGMENT_SHADER_INVOCATIONS [FragmentShaderInvocations] = vks::core::VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT;
395        const TESSELLATION_CONTROL_SHADER_PATCHES [TessellationControlShaderPatches] = vks::core::VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT;
396        const TESSELLATION_EVALUATION_SHADER_INVOCATIONS [TessellationEvaluationShaderInvocations] = vks::core::VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT;
397        const COMPUTE_SHADER_INVOCATIONS [ComputeShaderInvocations] = vks::core::VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT;
398    }
399
400    no_bits {}
401}
402
403dacite_bitflags! {
404    /// See [`VkQueryResultFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkQueryResultFlagBits)
405    pub struct QueryResultFlags: vks::core::VkQueryResultFlags;
406    pub enum QueryResultFlagBits: vks::core::VkQueryResultFlagBits;
407    max_enum: vks::core::VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM;
408
409    flags {
410        const RESULT_64 [Result64] = vks::core::VK_QUERY_RESULT_64_BIT;
411        const WAIT [Wait] = vks::core::VK_QUERY_RESULT_WAIT_BIT;
412        const WITH_AVAILABILITY [WithAvailability] = vks::core::VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
413        const PARTIAL [Partial] = vks::core::VK_QUERY_RESULT_PARTIAL_BIT;
414    }
415
416    no_bits {}
417}
418
419dacite_bitflags! {
420    /// See [`VkBufferCreateFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBufferCreateFlagBits)
421    pub struct BufferCreateFlags: vks::core::VkBufferCreateFlags;
422    pub enum BufferCreateFlagBits: vks::core::VkBufferCreateFlagBits;
423    max_enum: vks::core::VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM;
424
425    flags {
426        const SPARSE_BINDING [SparseBinding] = vks::core::VK_BUFFER_CREATE_SPARSE_BINDING_BIT;
427        const SPARSE_RESIDENCY [SparseResidency] = vks::core::VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT;
428        const SPARSE_ALIASED [SparseAliased] = vks::core::VK_BUFFER_CREATE_SPARSE_ALIASED_BIT;
429    }
430
431    no_bits {}
432}
433
434dacite_bitflags! {
435    /// See [`VkBufferUsageFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBufferUsageFlagBits)
436    pub struct BufferUsageFlags: vks::core::VkBufferUsageFlags;
437    pub enum BufferUsageFlagBits: vks::core::VkBufferUsageFlagBits;
438    max_enum: vks::core::VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM;
439
440    flags {
441        const TRANSFER_SRC [TransferSrc] = vks::core::VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
442        const TRANSFER_DST [TransferDst] = vks::core::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
443        const UNIFORM_TEXEL_BUFFER [UniformTexelBuffer] = vks::core::VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
444        const STORAGE_TEXEL_BUFFER [StorageTexelBuffer] = vks::core::VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
445        const UNIFORM_BUFFER [UniformBuffer] = vks::core::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
446        const STORAGE_BUFFER [StorageBuffer] = vks::core::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
447        const INDEX_BUFFER [IndexBuffer] = vks::core::VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
448        const VERTEX_BUFFER [VertexBuffer] = vks::core::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
449        const INDIRECT_BUFFER [IndirectBuffer] = vks::core::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
450    }
451
452    no_bits {}
453}
454
455dacite_bitflags! {
456    /// See [`VkBufferViewCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBufferViewCreateFlags)
457    pub struct BufferViewCreateFlags: vks::core::VkBufferViewCreateFlags;
458    pub enum BufferViewCreateFlagBits: vks::core::VkBufferViewCreateFlagBits;
459    max_enum: vks::core::VK_BUFFER_VIEW_CREATE_FLAG_BITS_MAX_ENUM;
460
461    flags {}
462    no_bits {}
463}
464
465dacite_bitflags! {
466    /// See [`VkImageViewCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageViewCreateFlags)
467    pub struct ImageViewCreateFlags: vks::core::VkImageViewCreateFlags;
468    pub enum ImageViewCreateFlagBits: vks::core::VkImageViewCreateFlagBits;
469    max_enum: vks::core::VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM;
470
471    flags {}
472    no_bits {}
473}
474
475dacite_bitflags! {
476    /// See [`VkShaderModuleCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkShaderModuleCreateFlags)
477    pub struct ShaderModuleCreateFlags: vks::core::VkShaderModuleCreateFlags;
478    pub enum ShaderModuleCreateFlagBits: vks::core::VkShaderModuleCreateFlagBits;
479    max_enum: vks::core::VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM;
480
481    flags {}
482    no_bits {}
483}
484
485dacite_bitflags! {
486    /// See [`VkPipelineCacheCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineCacheCreateFlags)
487    pub struct PipelineCacheCreateFlags: vks::core::VkPipelineCacheCreateFlags;
488    pub enum PipelineCacheCreateFlagBits: vks::core::VkPipelineCacheCreateFlagBits;
489    max_enum: vks::core::VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM;
490
491    flags {}
492    no_bits {}
493}
494
495dacite_bitflags! {
496    /// See [`VkPipelineCreateFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineCreateFlagBits)
497    pub struct PipelineCreateFlags: vks::core::VkPipelineCreateFlags;
498    pub enum PipelineCreateFlagBits: vks::core::VkPipelineCreateFlagBits;
499    max_enum: vks::core::VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM;
500
501    flags {
502        const DISABLE_OPTIMIZATION [DisableOptimization] = vks::core::VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT;
503        const ALLOW_DERIVATIVES [AllowDerivatives] = vks::core::VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT;
504        const DERIVATIVE [Derivative] = vks::core::VK_PIPELINE_CREATE_DERIVATIVE_BIT;
505    }
506
507    no_bits {}
508}
509
510dacite_bitflags! {
511    /// See [`VkPipelineShaderStageCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineShaderStageCreateFlags)
512    pub struct PipelineShaderStageCreateFlags: vks::core::VkPipelineShaderStageCreateFlags;
513    pub enum PipelineShaderStageCreateFlagBits: vks::core::VkPipelineShaderStageCreateFlagBits;
514    max_enum: vks::core::VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM;
515
516    flags {}
517    no_bits {}
518}
519
520dacite_bitflags! {
521    /// See [`VkShaderStageFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkShaderStageFlagBits)
522    pub struct ShaderStageFlags: vks::core::VkShaderStageFlags;
523    pub enum ShaderStageFlagBits: vks::core::VkShaderStageFlagBits;
524    max_enum: vks::core::VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM;
525
526    flags {
527        const VERTEX [Vertex] = vks::core::VK_SHADER_STAGE_VERTEX_BIT;
528        const TESSELLATION_CONTROL [TessellationControl] = vks::core::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
529        const TESSELLATION_EVALUATION [TessellationEvaluation] = vks::core::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
530        const GEOMETRY [Geometry] = vks::core::VK_SHADER_STAGE_GEOMETRY_BIT;
531        const FRAGMENT [Fragment] = vks::core::VK_SHADER_STAGE_FRAGMENT_BIT;
532        const COMPUTE [Compute] = vks::core::VK_SHADER_STAGE_COMPUTE_BIT;
533    }
534
535    no_bits {
536        const ALL_GRAPHICS = vks::core::VK_SHADER_STAGE_ALL_GRAPHICS;
537        const ALL = vks::core::VK_SHADER_STAGE_ALL;
538    }
539}
540
541dacite_bitflags! {
542    /// See [`VkPipelineVertexInputStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineVertexInputStateCreateFlags)
543    pub struct PipelineVertexInputStateCreateFlags: vks::core::VkPipelineVertexInputStateCreateFlags;
544    pub enum PipelineVertexInputStateCreateFlagBits: vks::core::VkPipelineVertexInputStateCreateFlagBits;
545    max_enum: vks::core::VK_PIPELINE_VERTEX_INPUT_STATE_CREATE_FLAG_BITS_MAX_ENUM;
546
547    flags {}
548    no_bits {}
549}
550
551dacite_bitflags! {
552    /// See [`VkPipelineInputAssemblyStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineInputAssemblyStateCreateFlags)
553    pub struct PipelineInputAssemblyStateCreateFlags: vks::core::VkPipelineInputAssemblyStateCreateFlags;
554    pub enum PipelineInputAssemblyStateCreateFlagBits: vks::core::VkPipelineInputAssemblyStateCreateFlagBits;
555    max_enum: vks::core::VK_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_FLAG_BITS_MAX_ENUM;
556
557    flags {}
558    no_bits {}
559}
560
561dacite_bitflags! {
562    /// See [`VkPipelineTessellationStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineTessellationStateCreateFlags)
563    pub struct PipelineTessellationStateCreateFlags: vks::core::VkPipelineTessellationStateCreateFlags;
564    pub enum PipelineTessellationStateCreateFlagBits: vks::core::VkPipelineTessellationStateCreateFlagBits;
565    max_enum: vks::core::VK_PIPELINE_TESSELLATION_STATE_CREATE_FLAG_BITS_MAX_ENUM;
566
567    flags {}
568    no_bits {}
569}
570
571dacite_bitflags! {
572    /// See [`VkPipelineViewportStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineViewportStateCreateFlags)
573    pub struct PipelineViewportStateCreateFlags: vks::core::VkPipelineViewportStateCreateFlags;
574    pub enum PipelineViewportStateCreateFlagBits: vks::core::VkPipelineViewportStateCreateFlagBits;
575    max_enum: vks::core::VK_PIPELINE_VIEWPORT_STATE_CREATE_FLAG_BITS_MAX_ENUM;
576
577    flags {}
578    no_bits {}
579}
580
581dacite_bitflags! {
582    /// See [`VkPipelineRasterizationStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineRasterizationStateCreateFlags)
583    pub struct PipelineRasterizationStateCreateFlags: vks::core::VkPipelineRasterizationStateCreateFlags;
584    pub enum PipelineRasterizationStateCreateFlagBits: vks::core::VkPipelineRasterizationStateCreateFlagBits;
585    max_enum: vks::core::VK_PIPELINE_RASTERIZATION_STATE_CREATE_FLAG_BITS_MAX_ENUM;
586
587    flags {}
588    no_bits {}
589}
590
591dacite_bitflags! {
592    /// See [`VkCullModeFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCullModeFlagBits)
593    pub struct CullModeFlags: vks::core::VkCullModeFlags;
594    pub enum CullModeFlagBits: vks::core::VkCullModeFlagBits;
595    max_enum: vks::core::VK_CULL_MODE_FLAG_BITS_MAX_ENUM;
596
597    flags {
598        const FRONT [Front] = vks::core::VK_CULL_MODE_FRONT_BIT;
599        const BACK [Back] = vks::core::VK_CULL_MODE_BACK_BIT;
600    }
601
602    no_bits {
603        const NONE = vks::core::VK_CULL_MODE_NONE;
604        const FRONT_AND_BACK = vks::core::VK_CULL_MODE_FRONT_AND_BACK;
605    }
606}
607
608dacite_bitflags! {
609    /// See [`VkPipelineMultisampleStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineMultisampleStateCreateFlags)
610    pub struct PipelineMultisampleStateCreateFlags: vks::core::VkPipelineMultisampleStateCreateFlags;
611    pub enum PipelineMultisampleStateCreateFlagBits: vks::core::VkPipelineMultisampleStateCreateFlagBits;
612    max_enum: vks::core::VK_PIPELINE_MULTISAMPLE_STATE_CREATE_FLAG_BITS_MAX_ENUM;
613
614    flags {}
615    no_bits {}
616}
617
618dacite_bitflags! {
619    /// See [`VkPipelineDepthStencilStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineDepthStencilStateCreateFlags)
620    pub struct PipelineDepthStencilStateCreateFlags: vks::core::VkPipelineDepthStencilStateCreateFlags;
621    pub enum PipelineDepthStencilStateCreateFlagBits: vks::core::VkPipelineDepthStencilStateCreateFlagBits;
622    max_enum: vks::core::VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM;
623
624    flags {}
625    no_bits {}
626}
627
628dacite_bitflags! {
629    /// See [`VkPipelineColorBlendStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineColorBlendStateCreateFlags)
630    pub struct PipelineColorBlendStateCreateFlags: vks::core::VkPipelineColorBlendStateCreateFlags;
631    pub enum PipelineColorBlendStateCreateFlagBits: vks::core::VkPipelineColorBlendStateCreateFlagBits;
632    max_enum: vks::core::VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM;
633
634    flags {}
635    no_bits {}
636}
637
638dacite_bitflags! {
639    /// See [`VkColorComponentFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkColorComponentFlagBits)
640    pub struct ColorComponentFlags: vks::core::VkColorComponentFlags;
641    pub enum ColorComponentFlagBits: vks::core::VkColorComponentFlagBits;
642    max_enum: vks::core::VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM;
643
644    flags {
645        const R [R] = vks::core::VK_COLOR_COMPONENT_R_BIT;
646        const G [G] = vks::core::VK_COLOR_COMPONENT_G_BIT;
647        const B [B] = vks::core::VK_COLOR_COMPONENT_B_BIT;
648        const A [A] = vks::core::VK_COLOR_COMPONENT_A_BIT;
649    }
650
651    no_bits {}
652}
653
654dacite_bitflags! {
655    /// See [`VkPipelineDynamicStateCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineDynamicStateCreateFlags)
656    pub struct PipelineDynamicStateCreateFlags: vks::core::VkPipelineDynamicStateCreateFlags;
657    pub enum PipelineDynamicStateCreateFlagBits: vks::core::VkPipelineDynamicStateCreateFlagBits;
658    max_enum: vks::core::VK_PIPELINE_DYNAMIC_STATE_CREATE_FLAG_BITS_MAX_ENUM;
659
660    flags {}
661    no_bits {}
662}
663
664dacite_bitflags! {
665    /// See [`VkPipelineLayoutCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineLayoutCreateFlags)
666    pub struct PipelineLayoutCreateFlags: vks::core::VkPipelineLayoutCreateFlags;
667    pub enum PipelineLayoutCreateFlagBits: vks::core::VkPipelineLayoutCreateFlagBits;
668    max_enum: vks::core::VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM;
669
670    flags {}
671    no_bits {}
672}
673
674dacite_bitflags! {
675    /// See [`VkSamplerCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSamplerCreateFlags)
676    pub struct SamplerCreateFlags: vks::core::VkSamplerCreateFlags;
677    pub enum SamplerCreateFlagBits: vks::core::VkSamplerCreateFlagBits;
678    max_enum: vks::core::VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM;
679
680    flags {}
681    no_bits {}
682}
683
684dacite_bitflags! {
685    /// See [`VkDescriptorSetLayoutCreateFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorSetLayoutCreateFlagBits)
686    pub struct DescriptorSetLayoutCreateFlags: vks::core::VkDescriptorSetLayoutCreateFlags;
687    pub enum DescriptorSetLayoutCreateFlagBits: vks::core::VkDescriptorSetLayoutCreateFlagBits;
688    max_enum: vks::core::VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM;
689
690    flags {}
691    no_bits {}
692}
693
694dacite_bitflags! {
695    /// See [`VkDescriptorPoolCreateFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorPoolCreateFlagBits)
696    pub struct DescriptorPoolCreateFlags: vks::core::VkDescriptorPoolCreateFlags;
697    pub enum DescriptorPoolCreateFlagBits: vks::core::VkDescriptorPoolCreateFlagBits;
698    max_enum: vks::core::VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM;
699
700    flags {
701        const FREE_DESCRIPTOR_SET [FreeDescriptorSet] = vks::core::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
702    }
703
704    no_bits {}
705}
706
707dacite_bitflags! {
708    /// See [`VkDescriptorPoolResetFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorPoolResetFlags)
709    pub struct DescriptorPoolResetFlags: vks::core::VkDescriptorPoolResetFlags;
710    pub enum DescriptorPoolResetFlagBits: vks::core::VkDescriptorPoolResetFlagBits;
711    max_enum: vks::core::VK_DESCRIPTOR_POOL_RESET_FLAG_BITS_MAX_ENUM;
712
713    flags {}
714    no_bits {}
715}
716
717dacite_bitflags! {
718    /// See [`VkFramebufferCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFramebufferCreateFlags)
719    pub struct FramebufferCreateFlags: vks::core::VkFramebufferCreateFlags;
720    pub enum FramebufferCreateFlagBits: vks::core::VkFramebufferCreateFlagBits;
721    max_enum: vks::core::VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM;
722
723    flags {}
724    no_bits {}
725}
726
727dacite_bitflags! {
728    /// See [`VkRenderPassCreateFlags`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkRenderPassCreateFlags)
729    pub struct RenderPassCreateFlags: vks::core::VkRenderPassCreateFlags;
730    pub enum RenderPassCreateFlagBits: vks::core::VkRenderPassCreateFlagBits;
731    max_enum: vks::core::VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM;
732
733    flags {}
734    no_bits {}
735}
736
737dacite_bitflags! {
738    /// See [`VkAttachmentDescriptionFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkAttachmentDescriptionFlagBits)
739    pub struct AttachmentDescriptionFlags: vks::core::VkAttachmentDescriptionFlags;
740    pub enum AttachmentDescriptionFlagBits: vks::core::VkAttachmentDescriptionFlagBits;
741    max_enum: vks::core::VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM;
742
743    flags {
744        const MAY_ALIAS [MayAlias] = vks::core::VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT;
745    }
746
747    no_bits {}
748}
749
750dacite_bitflags! {
751    /// See [`VkSubpassDescriptionFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSubpassDescriptionFlagBits)
752    pub struct SubpassDescriptionFlags: vks::core::VkSubpassDescriptionFlags;
753    pub enum SubpassDescriptionFlagBits: vks::core::VkSubpassDescriptionFlagBits;
754    max_enum: vks::core::VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM;
755
756    flags {}
757    no_bits {}
758}
759
760dacite_bitflags! {
761    /// See [`VkAccessFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkAccessFlagBits)
762    pub struct AccessFlags: vks::core::VkAccessFlags;
763    pub enum AccessFlagBits: vks::core::VkAccessFlagBits;
764    max_enum: vks::core::VK_ACCESS_FLAG_BITS_MAX_ENUM;
765
766    flags {
767        const INDIRECT_COMMAND_READ [IndirectCommandRead] = vks::core::VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
768        const INDEX_READ [IndexRead] = vks::core::VK_ACCESS_INDEX_READ_BIT;
769        const VERTEX_ATTRIBUTE_READ [VertexAttributeRead] = vks::core::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
770        const UNIFORM_READ [UniformRead] = vks::core::VK_ACCESS_UNIFORM_READ_BIT;
771        const INPUT_ATTACHMENT_READ [InputAttachmentRead] = vks::core::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
772        const SHADER_READ [ShaderRead] = vks::core::VK_ACCESS_SHADER_READ_BIT;
773        const SHADER_WRITE [ShaderWrite] = vks::core::VK_ACCESS_SHADER_WRITE_BIT;
774        const COLOR_ATTACHMENT_READ [ColorAttachmentRead] = vks::core::VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
775        const COLOR_ATTACHMENT_WRITE [ColorAttachmentWrite] = vks::core::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
776        const DEPTH_STENCIL_ATTACHMENT_READ [DepthStencilAttachmentRead] = vks::core::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
777        const DEPTH_STENCIL_ATTACHMENT_WRITE [DepthStencilAttachmentWrite] = vks::core::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
778        const TRANSFER_READ [TransferRead] = vks::core::VK_ACCESS_TRANSFER_READ_BIT;
779        const TRANSFER_WRITE [TransferWrite] = vks::core::VK_ACCESS_TRANSFER_WRITE_BIT;
780        const HOST_READ [HostRead] = vks::core::VK_ACCESS_HOST_READ_BIT;
781        const HOST_WRITE [HostWrite] = vks::core::VK_ACCESS_HOST_WRITE_BIT;
782        const MEMORY_READ [MemoryRead] = vks::core::VK_ACCESS_MEMORY_READ_BIT;
783        const MEMORY_WRITE [MemoryWrite] = vks::core::VK_ACCESS_MEMORY_WRITE_BIT;
784    }
785
786    no_bits {}
787}
788
789dacite_bitflags! {
790    /// See [`VkDependencyFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDependencyFlagBits)
791    pub struct DependencyFlags: vks::core::VkDependencyFlags;
792    pub enum DependencyFlagBits: vks::core::VkDependencyFlagBits;
793    max_enum: vks::core::VK_DEPENDENCY_FLAG_BITS_MAX_ENUM;
794
795    flags {
796        const BY_REGION [ByRegion] = vks::core::VK_DEPENDENCY_BY_REGION_BIT;
797    }
798
799    no_bits {}
800}
801
802dacite_bitflags! {
803    /// See [`VkCommandPoolCreateFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandPoolCreateFlagBits)
804    pub struct CommandPoolCreateFlags: vks::core::VkCommandPoolCreateFlags;
805    pub enum CommandPoolCreateFlagBits: vks::core::VkCommandPoolCreateFlagBits;
806    max_enum: vks::core::VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM;
807
808    flags {
809        const TRANSIENT [Transient] = vks::core::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
810        const RESET_COMMAND_BUFFER [ResetCommandBuffer] = vks::core::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
811    }
812
813    no_bits {}
814}
815
816dacite_bitflags! {
817    /// See [`VkCommandPoolResetFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandPoolResetFlagBits)
818    pub struct CommandPoolResetFlags: vks::core::VkCommandPoolResetFlags;
819    pub enum CommandPoolResetFlagBits: vks::core::VkCommandPoolResetFlagBits;
820    max_enum: vks::core::VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM;
821
822    flags {
823        const RELEASE_RESOURCES [ReleaseResources] = vks::core::VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT;
824    }
825
826    no_bits {}
827}
828
829dacite_bitflags! {
830    /// See [`VkCommandBufferUsageFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandBufferUsageFlagBits)
831    pub struct CommandBufferUsageFlags: vks::core::VkCommandBufferUsageFlags;
832    pub enum CommandBufferUsageFlagBits: vks::core::VkCommandBufferUsageFlagBits;
833    max_enum: vks::core::VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM;
834
835    flags {
836        const ONE_TIME_SUBMIT [OneTimeSubmit] = vks::core::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
837        const RENDER_PASS_CONTINUE [RenderPassContinue] = vks::core::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
838        const SIMULTANEOUS_USE [SimultaneousUse] = vks::core::VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
839    }
840
841    no_bits {}
842}
843
844dacite_bitflags! {
845    /// See [`VkQueryControlFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkQueryControlFlagBits)
846    pub struct QueryControlFlags: vks::core::VkQueryControlFlags;
847    pub enum QueryControlFlagBits: vks::core::VkQueryControlFlagBits;
848    max_enum: vks::core::VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM;
849
850    flags {
851        const PRECISE [Precise] = vks::core::VK_QUERY_CONTROL_PRECISE_BIT;
852    }
853
854    no_bits {}
855}
856
857dacite_bitflags! {
858    /// See [`VkCommandBufferResetFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandBufferResetFlagBits)
859    pub struct CommandBufferResetFlags: vks::core::VkCommandBufferResetFlags;
860    pub enum CommandBufferResetFlagBits: vks::core::VkCommandBufferResetFlagBits;
861    max_enum: vks::core::VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM;
862
863    flags {
864        const RELEASE_RESOURCES [ReleaseResources] = vks::core::VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT;
865    }
866
867    no_bits {}
868}
869
870dacite_bitflags! {
871    /// See [`VkStencilFaceFlagBits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkStencilFaceFlagBits)
872    pub struct StencilFaceFlags: vks::core::VkStencilFaceFlags;
873    pub enum StencilFaceFlagBits: vks::core::VkStencilFaceFlagBits;
874    max_enum: vks::core::VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM;
875
876    flags {
877        const FRONT [Front] = vks::core::VK_STENCIL_FACE_FRONT_BIT;
878        const BACK [Back] = vks::core::VK_STENCIL_FACE_BACK_BIT;
879    }
880
881    no_bits {
882        const FRONT_AND_BACK = vks::core::VK_STENCIL_FRONT_AND_BACK;
883    }
884}
885
886#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
887pub enum OptionalDeviceSize {
888    Size(u64),
889    WholeSize,
890}
891
892impl From<OptionalDeviceSize> for u64 {
893    fn from(size: OptionalDeviceSize) -> Self {
894        match size {
895            OptionalDeviceSize::Size(size) => size,
896            OptionalDeviceSize::WholeSize => vks::core::VK_WHOLE_SIZE,
897        }
898    }
899}
900
901#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
902pub enum OptionalMipLevels {
903    MipLevels(u32),
904    Remaining,
905}
906
907impl From<OptionalMipLevels> for u32 {
908    fn from(mip_levels: OptionalMipLevels) -> Self {
909        match mip_levels {
910            OptionalMipLevels::MipLevels(mip_levels) => mip_levels,
911            OptionalMipLevels::Remaining => vks::core::VK_REMAINING_MIP_LEVELS,
912        }
913    }
914}
915
916#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
917pub enum OptionalArrayLayers {
918    ArrayLayers(u32),
919    Remaining,
920}
921
922impl From<OptionalArrayLayers> for u32 {
923    fn from(array_layers: OptionalArrayLayers) -> Self {
924        match array_layers {
925            OptionalArrayLayers::ArrayLayers(array_layers) => array_layers,
926            OptionalArrayLayers::Remaining => vks::core::VK_REMAINING_ARRAY_LAYERS,
927        }
928    }
929}
930
931#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
932pub enum AttachmentIndex {
933    Index(u32),
934    Unused,
935}
936
937impl From<AttachmentIndex> for u32 {
938    fn from(index: AttachmentIndex) -> Self {
939        match index {
940            AttachmentIndex::Index(index) => index,
941            AttachmentIndex::Unused => vks::core::VK_ATTACHMENT_UNUSED
942        }
943    }
944}
945
946impl From<u32> for AttachmentIndex {
947    fn from(index: u32) -> Self {
948        match index {
949            vks::core::VK_ATTACHMENT_UNUSED => AttachmentIndex::Unused,
950            _ => AttachmentIndex::Index(index),
951        }
952    }
953}
954
955#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
956pub enum QueueFamilyIndex {
957    Index(u32),
958    Ignored,
959}
960
961impl From<QueueFamilyIndex> for u32 {
962    fn from(index: QueueFamilyIndex) -> Self {
963        match index {
964            QueueFamilyIndex::Index(index) => index,
965            QueueFamilyIndex::Ignored => vks::core::VK_QUEUE_FAMILY_IGNORED,
966        }
967    }
968}
969
970#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
971pub enum SubpassIndex {
972    Index(u32),
973    External,
974}
975
976impl From<SubpassIndex> for u32 {
977    fn from(index: SubpassIndex) -> Self {
978        match index {
979            SubpassIndex::Index(index) => index,
980            SubpassIndex::External => vks::core::VK_SUBPASS_EXTERNAL,
981        }
982    }
983}
984
985impl From<u32> for SubpassIndex {
986    fn from(index: u32) -> Self {
987        match index {
988            vks::core::VK_SUBPASS_EXTERNAL => SubpassIndex::External,
989            _ => SubpassIndex::Index(index),
990        }
991    }
992}
993
994#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
995pub enum QueryResult {
996    U32(u32),
997    U64(u64),
998}
999
1000#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1001pub enum Timeout {
1002    None,
1003    Some(Duration),
1004    Infinite,
1005}
1006
1007impl Timeout {
1008    #[inline]
1009    pub fn as_nanoseconds(&self) -> u64 {
1010        match *self {
1011            Timeout::None => 0,
1012            Timeout::Some(ref d) => 1_000_000_000u64 * d.as_secs() + u64::from(d.subsec_nanos()),
1013            Timeout::Infinite => u64::max_value(),
1014        }
1015    }
1016}
1017
1018/// See [API Version Numbers](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#fundamentals-versionnum)
1019#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1020pub struct Version {
1021    pub major: u32,
1022    pub minor: u32,
1023    pub patch: u32,
1024}
1025
1026impl fmt::Display for Version {
1027    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1028        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
1029    }
1030}
1031
1032impl Version {
1033    pub fn from_api_version(version: u32) -> Self {
1034        Version {
1035            major: vks::vk_version_major(version),
1036            minor: vks::vk_version_minor(version),
1037            patch: vks::vk_version_patch(version),
1038        }
1039    }
1040
1041    pub fn from_optional_api_version(version: u32) -> Option<Self> {
1042        if version != 0 {
1043            Some(Version::from_api_version(version))
1044        }
1045        else {
1046            None
1047        }
1048    }
1049
1050    pub fn as_api_version(&self) -> u32 {
1051        vks::vk_make_version(self.major, self.minor, self.patch)
1052    }
1053
1054    pub fn api_version_from_optional(version: Option<Version>) -> u32 {
1055        match version {
1056            Some(version) => version.as_api_version(),
1057            None => 0,
1058        }
1059    }
1060}
1061
1062pub const LOD_CLAMP_NONE: f32 = vks::core::VK_LOD_CLAMP_NONE;
1063pub const REMAINING_MIP_LEVELS: u32 = vks::core::VK_REMAINING_MIP_LEVELS;
1064pub const REMAINING_ARRAY_LAYERS: u32 = vks::core::VK_REMAINING_ARRAY_LAYERS;
1065pub const WHOLE_SIZE: u64 = vks::core::VK_WHOLE_SIZE;
1066pub const ATTACHMENT_UNUSED: u32 = vks::core::VK_ATTACHMENT_UNUSED;
1067pub const QUEUE_FAMILY_IGNORED: u32 = vks::core::VK_QUEUE_FAMILY_IGNORED;
1068pub const SUBPASS_EXTERNAL: u32 = vks::core::VK_SUBPASS_EXTERNAL;
1069pub const MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = vks::core::VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
1070pub const UUID_SIZE: usize = vks::core::VK_UUID_SIZE;
1071pub const MAX_MEMORY_TYPES: usize = vks::core::VK_MAX_MEMORY_TYPES;
1072pub const MAX_MEMORY_HEAPS: usize = vks::core::VK_MAX_MEMORY_HEAPS;
1073pub const MAX_EXTENSION_NAME_SIZE: usize = vks::core::VK_MAX_EXTENSION_NAME_SIZE;
1074pub const MAX_DESCRIPTION_SIZE: usize = vks::core::VK_MAX_DESCRIPTION_SIZE;
1075
1076/// See [`VkPipelineCacheHeaderVersion`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineCacheHeaderVersion)
1077#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1078pub enum PipelineCacheHeaderVersion {
1079    One,
1080    Unknown(vks::core::VkPipelineCacheHeaderVersion),
1081}
1082
1083/// See [`VkResult`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkResult)
1084#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1085pub enum Error {
1086    OutOfHostMemory,
1087    OutOfDeviceMemory,
1088    InitializationFailed,
1089    DeviceLost,
1090    MemoryMapFailed,
1091    LayerNotPresent,
1092    ExtensionNotPresent,
1093    FeatureNotPresent,
1094    IncompatibleDriver,
1095    TooManyObjects,
1096    FormatNotSupported,
1097    FragmentedPool,
1098
1099    /// See extension [`VK_KHR_surface`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_KHR_surface)
1100    SurfaceLostKhr,
1101
1102    /// See extension [`VK_KHR_surface`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_KHR_surface)
1103    NativeWindowInUseKhr,
1104
1105    /// See extension [`VK_EXT_debug_report`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_EXT_debug_report)
1106    ValidationFailedExt,
1107
1108    /// See extension [`VK_KHR_swapchain`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_KHR_swapchain)
1109    OutOfDateKhr,
1110
1111    /// See extension [`VK_KHR_display_swapchain`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_KHR_display_swapchain)
1112    IncompatibleDisplayKhr,
1113
1114    /// See extension [`VK_NV_glsl_shader`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_NV_glsl_shader)
1115    InvalidShaderNv,
1116
1117    Unknown(vks::core::VkResult),
1118}
1119
1120impl fmt::Display for Error {
1121    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1122        write!(f, "{}", ::std::error::Error::description(self))
1123    }
1124}
1125
1126impl ::std::error::Error for Error {
1127    fn description(&self) -> &str {
1128        match *self {
1129            Error::OutOfHostMemory => "OutOfHostMemory",
1130            Error::OutOfDeviceMemory => "OutOfDeviceMemory",
1131            Error::InitializationFailed => "InitializationFailed",
1132            Error::DeviceLost => "DeviceLost",
1133            Error::MemoryMapFailed => "MemoryMapFailed",
1134            Error::LayerNotPresent => "LayerNotPresent",
1135            Error::ExtensionNotPresent => "ExtensionNotPresent",
1136            Error::FeatureNotPresent => "FeatureNotPresent",
1137            Error::IncompatibleDriver => "IncompatibleDriver",
1138            Error::TooManyObjects => "TooManyObjects",
1139            Error::FormatNotSupported => "FormatNotSupported",
1140            Error::FragmentedPool => "FragmentedPool",
1141            Error::SurfaceLostKhr => "SurfaceLost",
1142            Error::NativeWindowInUseKhr => "NativeWindowInUse",
1143            Error::ValidationFailedExt => "ValidationFailed",
1144            Error::OutOfDateKhr => "OutOfDate",
1145            Error::IncompatibleDisplayKhr => "IncompatibleDisplay",
1146            Error::InvalidShaderNv => "InvalidShader",
1147            Error::Unknown(_) => "unknown error",
1148        }
1149    }
1150}
1151
1152impl From<vks::core::VkResult> for Error {
1153    fn from(res: vks::core::VkResult) -> Self {
1154        debug_assert!(res < 0);
1155
1156        match res {
1157            vks::core::VK_ERROR_OUT_OF_HOST_MEMORY => Error::OutOfHostMemory,
1158            vks::core::VK_ERROR_OUT_OF_DEVICE_MEMORY => Error::OutOfDeviceMemory,
1159            vks::core::VK_ERROR_INITIALIZATION_FAILED => Error::InitializationFailed,
1160            vks::core::VK_ERROR_DEVICE_LOST => Error::DeviceLost,
1161            vks::core::VK_ERROR_MEMORY_MAP_FAILED => Error::MemoryMapFailed,
1162            vks::core::VK_ERROR_LAYER_NOT_PRESENT => Error::LayerNotPresent,
1163            vks::core::VK_ERROR_EXTENSION_NOT_PRESENT => Error::ExtensionNotPresent,
1164            vks::core::VK_ERROR_FEATURE_NOT_PRESENT => Error::FeatureNotPresent,
1165            vks::core::VK_ERROR_INCOMPATIBLE_DRIVER => Error::IncompatibleDriver,
1166            vks::core::VK_ERROR_TOO_MANY_OBJECTS => Error::TooManyObjects,
1167            vks::core::VK_ERROR_FORMAT_NOT_SUPPORTED => Error::FormatNotSupported,
1168            vks::core::VK_ERROR_FRAGMENTED_POOL => Error::FragmentedPool,
1169            vks::core::VK_ERROR_SURFACE_LOST_KHR => Error::SurfaceLostKhr,
1170            vks::core::VK_ERROR_NATIVE_WINDOW_IN_USE_KHR => Error::NativeWindowInUseKhr,
1171            vks::core::VK_ERROR_VALIDATION_FAILED_EXT => Error::ValidationFailedExt,
1172            vks::core::VK_ERROR_OUT_OF_DATE_KHR => Error::OutOfDateKhr,
1173            vks::core::VK_ERROR_INCOMPATIBLE_DISPLAY_KHR => Error::IncompatibleDisplayKhr,
1174            vks::core::VK_ERROR_INVALID_SHADER_NV => Error::InvalidShaderNv,
1175            _ => Error::Unknown(res),
1176        }
1177    }
1178}
1179
1180impl From<Error> for vks::core::VkResult {
1181    fn from(e: Error) -> Self {
1182        match e {
1183            Error::OutOfHostMemory => vks::core::VK_ERROR_OUT_OF_HOST_MEMORY,
1184            Error::OutOfDeviceMemory => vks::core::VK_ERROR_OUT_OF_DEVICE_MEMORY,
1185            Error::InitializationFailed => vks::core::VK_ERROR_INITIALIZATION_FAILED,
1186            Error::DeviceLost => vks::core::VK_ERROR_DEVICE_LOST,
1187            Error::MemoryMapFailed => vks::core::VK_ERROR_MEMORY_MAP_FAILED,
1188            Error::LayerNotPresent => vks::core::VK_ERROR_LAYER_NOT_PRESENT,
1189            Error::ExtensionNotPresent => vks::core::VK_ERROR_EXTENSION_NOT_PRESENT,
1190            Error::FeatureNotPresent => vks::core::VK_ERROR_FEATURE_NOT_PRESENT,
1191            Error::IncompatibleDriver => vks::core::VK_ERROR_INCOMPATIBLE_DRIVER,
1192            Error::TooManyObjects => vks::core::VK_ERROR_TOO_MANY_OBJECTS,
1193            Error::FormatNotSupported => vks::core::VK_ERROR_FORMAT_NOT_SUPPORTED,
1194            Error::FragmentedPool => vks::core::VK_ERROR_FRAGMENTED_POOL,
1195            Error::SurfaceLostKhr => vks::core::VK_ERROR_SURFACE_LOST_KHR,
1196            Error::NativeWindowInUseKhr => vks::core::VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,
1197            Error::ValidationFailedExt => vks::core::VK_ERROR_VALIDATION_FAILED_EXT,
1198            Error::OutOfDateKhr => vks::core::VK_ERROR_OUT_OF_DATE_KHR,
1199            Error::IncompatibleDisplayKhr => vks::core::VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
1200            Error::InvalidShaderNv => vks::core::VK_ERROR_INVALID_SHADER_NV,
1201            Error::Unknown(res) => res,
1202        }
1203    }
1204}
1205
1206/// See [`VkSystemAllocationSope`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSystemAllocationSope)
1207#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1208pub enum SystemAllocationSope {
1209    Command,
1210    Object,
1211    Cache,
1212    Device,
1213    Instance,
1214    Unknown(vks::core::VkSystemAllocationScope),
1215}
1216
1217impl From<vks::core::VkSystemAllocationScope> for SystemAllocationSope {
1218    fn from(scope: vks::core::VkSystemAllocationScope) -> Self {
1219        match scope {
1220            vks::core::VK_SYSTEM_ALLOCATION_SCOPE_COMMAND => SystemAllocationSope::Command,
1221            vks::core::VK_SYSTEM_ALLOCATION_SCOPE_OBJECT => SystemAllocationSope::Object,
1222            vks::core::VK_SYSTEM_ALLOCATION_SCOPE_CACHE => SystemAllocationSope::Cache,
1223            vks::core::VK_SYSTEM_ALLOCATION_SCOPE_DEVICE => SystemAllocationSope::Device,
1224            vks::core::VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE => SystemAllocationSope::Instance,
1225            _ => SystemAllocationSope::Unknown(scope),
1226        }
1227    }
1228}
1229
1230/// See [`VkInternalAllocationType`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkInternalAllocationType)
1231#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1232pub enum InternalAllocationType {
1233    Executable,
1234    Unknown(vks::core::VkInternalAllocationType),
1235}
1236
1237impl From<vks::core::VkInternalAllocationType> for InternalAllocationType {
1238    fn from(allocation_type: vks::core::VkInternalAllocationType) -> Self {
1239        match allocation_type {
1240            vks::core::VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE => InternalAllocationType::Executable,
1241            _ => InternalAllocationType::Unknown(allocation_type),
1242        }
1243    }
1244}
1245
1246/// See [`VkFormat`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFormat)
1247#[allow(non_camel_case_types)]
1248#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1249pub enum Format {
1250    Undefined,
1251    R4G4_UNorm_Pack8,
1252    R4G4B4A4_UNorm_Pack16,
1253    B4G4R4A4_UNorm_Pack16,
1254    R5G6B5_UNorm_Pack16,
1255    B5G6R5_UNorm_Pack16,
1256    R5G5B5A1_UNorm_Pack16,
1257    B5G5R5A1_UNorm_Pack16,
1258    A1R5G5B5_UNorm_Pack16,
1259    R8_UNorm,
1260    R8_SNorm,
1261    R8_UScaled,
1262    R8_SScaled,
1263    R8_UInt,
1264    R8_SInt,
1265    R8_sRGB,
1266    R8G8_UNorm,
1267    R8G8_SNorm,
1268    R8G8_UScaled,
1269    R8G8_SScaled,
1270    R8G8_UInt,
1271    R8G8_SInt,
1272    R8G8_sRGB,
1273    R8G8B8_UNorm,
1274    R8G8B8_SNorm,
1275    R8G8B8_UScaled,
1276    R8G8B8_SScaled,
1277    R8G8B8_UInt,
1278    R8G8B8_SInt,
1279    R8G8B8_sRGB,
1280    B8G8R8_UNorm,
1281    B8G8R8_SNorm,
1282    B8G8R8_UScaled,
1283    B8G8R8_SScaled,
1284    B8G8R8_UInt,
1285    B8G8R8_SInt,
1286    B8G8R8_sRGB,
1287    R8G8B8A8_UNorm,
1288    R8G8B8A8_SNorm,
1289    R8G8B8A8_UScaled,
1290    R8G8B8A8_SScaled,
1291    R8G8B8A8_UInt,
1292    R8G8B8A8_SInt,
1293    R8G8B8A8_sRGB,
1294    B8G8R8A8_UNorm,
1295    B8G8R8A8_SNorm,
1296    B8G8R8A8_UScaled,
1297    B8G8R8A8_SScaled,
1298    B8G8R8A8_UInt,
1299    B8G8R8A8_SInt,
1300    B8G8R8A8_sRGB,
1301    A8B8G8R8_UNorm_Pack32,
1302    A8B8G8R8_SNorm_Pack32,
1303    A8B8G8R8_UScaled_Pack32,
1304    A8B8G8R8_SScaled_Pack32,
1305    A8B8G8R8_UInt_Pack32,
1306    A8B8G8R8_SInt_Pack32,
1307    A8B8G8R8_sRGB_Pack32,
1308    A2R10G10B10_UNorm_Pack32,
1309    A2R10G10B10_SNorm_Pack32,
1310    A2R10G10B10_UScaled_Pack32,
1311    A2R10G10B10_SScaled_Pack32,
1312    A2R10G10B10_UInt_Pack32,
1313    A2R10G10B10_SInt_Pack32,
1314    A2B10G10R10_UNorm_Pack32,
1315    A2B10G10R10_SNorm_Pack32,
1316    A2B10G10R10_UScaled_Pack32,
1317    A2B10G10R10_SScaled_Pack32,
1318    A2B10G10R10_UInt_Pack32,
1319    A2B10G10R10_SInt_Pack32,
1320    R16_UNorm,
1321    R16_SNorm,
1322    R16_UScaled,
1323    R16_SScaled,
1324    R16_UInt,
1325    R16_SInt,
1326    R16_SFloat,
1327    R16G16_UNorm,
1328    R16G16_SNorm,
1329    R16G16_UScaled,
1330    R16G16_SScaled,
1331    R16G16_UInt,
1332    R16G16_SInt,
1333    R16G16_SFloat,
1334    R16G16B16_UNorm,
1335    R16G16B16_SNorm,
1336    R16G16B16_UScaled,
1337    R16G16B16_SScaled,
1338    R16G16B16_UInt,
1339    R16G16B16_SInt,
1340    R16G16B16_SFloat,
1341    R16G16B16A16_UNorm,
1342    R16G16B16A16_SNorm,
1343    R16G16B16A16_UScaled,
1344    R16G16B16A16_SScaled,
1345    R16G16B16A16_UInt,
1346    R16G16B16A16_SInt,
1347    R16G16B16A16_SFloat,
1348    R32_UInt,
1349    R32_SInt,
1350    R32_SFloat,
1351    R32G32_UInt,
1352    R32G32_SInt,
1353    R32G32_SFloat,
1354    R32G32B32_UInt,
1355    R32G32B32_SInt,
1356    R32G32B32_SFloat,
1357    R32G32B32A32_UInt,
1358    R32G32B32A32_SInt,
1359    R32G32B32A32_SFloat,
1360    R64_UInt,
1361    R64_SInt,
1362    R64_SFloat,
1363    R64G64_UInt,
1364    R64G64_SInt,
1365    R64G64_SFloat,
1366    R64G64B64_UInt,
1367    R64G64B64_SInt,
1368    R64G64B64_SFloat,
1369    R64G64B64A64_UInt,
1370    R64G64B64A64_SInt,
1371    R64G64B64A64_SFloat,
1372    B10G11R11_UFloat_Pack32,
1373    E5B9G9R9_UFloat_Pack32,
1374    D16_UNorm,
1375    X8_D24_UNorm_Pack32,
1376    D32_SFloat,
1377    S8_UInt,
1378    D16_UNorm_S8_UInt,
1379    D24_UNorm_S8_UInt,
1380    D32_SFloat_S8_UInt,
1381    BC1_RGB_UNorm_Block,
1382    BC1_RGB_sRGB_Block,
1383    BC1_RGBA_UNorm_Block,
1384    BC1_RGBA_sRGB_Block,
1385    BC2_UNorm_Block,
1386    BC2_sRGB_Block,
1387    BC3_UNorm_Block,
1388    BC3_sRGB_Block,
1389    BC4_UNorm_Block,
1390    BC4_SNorm_Block,
1391    BC5_UNorm_Block,
1392    BC5_SNorm_Block,
1393    BC6H_UFloat_Block,
1394    BC6H_SFloat_Block,
1395    BC7_UNorm_Block,
1396    BC7_sRGB_Block,
1397    ETC2_R8G8B8_UNorm_Block,
1398    ETC2_R8G8B8_sRGB_Block,
1399    ETC2_R8G8B8A1_UNorm_Block,
1400    ETC2_R8G8B8A1_sRGB_Block,
1401    ETC2_R8G8B8A8_UNorm_Block,
1402    ETC2_R8G8B8A8_sRGB_Block,
1403    EAC_R11_UNorm_Block,
1404    EAC_R11_SNorm_Block,
1405    EAC_R11G11_UNorm_Block,
1406    EAC_R11G11_SNorm_Block,
1407    ASTC_4x4_UNorm_Block,
1408    ASTC_4x4_sRGB_Block,
1409    ASTC_5x4_UNorm_Block,
1410    ASTC_5x4_sRGB_Block,
1411    ASTC_5x5_UNorm_Block,
1412    ASTC_5x5_sRGB_Block,
1413    ASTC_6x5_UNorm_Block,
1414    ASTC_6x5_sRGB_Block,
1415    ASTC_6x6_UNorm_Block,
1416    ASTC_6x6_sRGB_Block,
1417    ASTC_8x5_UNorm_Block,
1418    ASTC_8x5_sRGB_Block,
1419    ASTC_8x6_UNorm_Block,
1420    ASTC_8x6_sRGB_Block,
1421    ASTC_8x8_UNorm_Block,
1422    ASTC_8x8_sRGB_Block,
1423    ASTC_10x5_UNorm_Block,
1424    ASTC_10x5_sRGB_Block,
1425    ASTC_10x6_UNorm_Block,
1426    ASTC_10x6_sRGB_Block,
1427    ASTC_10x8_UNorm_Block,
1428    ASTC_10x8_sRGB_Block,
1429    ASTC_10x10_UNorm_Block,
1430    ASTC_10x10_sRGB_Block,
1431    ASTC_12x10_UNorm_Block,
1432    ASTC_12x10_sRGB_Block,
1433    ASTC_12x12_UNorm_Block,
1434    ASTC_12x12_sRGB_Block,
1435
1436    /// See extension [`VK_IMG_format_pvrtc`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_format_pvrtc)
1437    PVRTC1_2BPP_UNorm_Block_Img,
1438
1439    /// See extension [`VK_IMG_format_pvrtc`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_format_pvrtc)
1440    PVRTC1_4BPP_UNorm_Block_Img,
1441
1442    /// See extension [`VK_IMG_format_pvrtc`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_format_pvrtc)
1443    PVRTC2_2BPP_UNorm_Block_Img,
1444
1445    /// See extension [`VK_IMG_format_pvrtc`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_format_pvrtc)
1446    PVRTC2_4BPP_UNorm_Block_Img,
1447
1448    /// See extension [`VK_IMG_format_pvrtc`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_format_pvrtc)
1449    PVRTC1_2BPP_sRGB_Block_Img,
1450
1451    /// See extension [`VK_IMG_format_pvrtc`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_format_pvrtc)
1452    PVRTC1_4BPP_sRGB_Block_Img,
1453
1454    /// See extension [`VK_IMG_format_pvrtc`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_format_pvrtc)
1455    PVRTC2_2BPP_sRGB_Block_Img,
1456
1457    /// See extension [`VK_IMG_format_pvrtc`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_IMG_format_pvrtc)
1458    PVRTC2_4BPP_sRGB_Block_Img,
1459
1460    Unknown(vks::core::VkFormat),
1461}
1462
1463impl From<vks::core::VkFormat> for Format {
1464    fn from(format: vks::core::VkFormat) -> Self {
1465        match format {
1466            vks::core::VK_FORMAT_UNDEFINED => Format::Undefined,
1467            vks::core::VK_FORMAT_R4G4_UNORM_PACK8 => Format::R4G4_UNorm_Pack8,
1468            vks::core::VK_FORMAT_R4G4B4A4_UNORM_PACK16 => Format::R4G4B4A4_UNorm_Pack16,
1469            vks::core::VK_FORMAT_B4G4R4A4_UNORM_PACK16 => Format::B4G4R4A4_UNorm_Pack16,
1470            vks::core::VK_FORMAT_R5G6B5_UNORM_PACK16 => Format::R5G6B5_UNorm_Pack16,
1471            vks::core::VK_FORMAT_B5G6R5_UNORM_PACK16 => Format::B5G6R5_UNorm_Pack16,
1472            vks::core::VK_FORMAT_R5G5B5A1_UNORM_PACK16 => Format::R5G5B5A1_UNorm_Pack16,
1473            vks::core::VK_FORMAT_B5G5R5A1_UNORM_PACK16 => Format::B5G5R5A1_UNorm_Pack16,
1474            vks::core::VK_FORMAT_A1R5G5B5_UNORM_PACK16 => Format::A1R5G5B5_UNorm_Pack16,
1475            vks::core::VK_FORMAT_R8_UNORM => Format::R8_UNorm,
1476            vks::core::VK_FORMAT_R8_SNORM => Format::R8_SNorm,
1477            vks::core::VK_FORMAT_R8_USCALED => Format::R8_UScaled,
1478            vks::core::VK_FORMAT_R8_SSCALED => Format::R8_SScaled,
1479            vks::core::VK_FORMAT_R8_UINT => Format::R8_UInt,
1480            vks::core::VK_FORMAT_R8_SINT => Format::R8_SInt,
1481            vks::core::VK_FORMAT_R8_SRGB => Format::R8_sRGB,
1482            vks::core::VK_FORMAT_R8G8_UNORM => Format::R8G8_UNorm,
1483            vks::core::VK_FORMAT_R8G8_SNORM => Format::R8G8_SNorm,
1484            vks::core::VK_FORMAT_R8G8_USCALED => Format::R8G8_UScaled,
1485            vks::core::VK_FORMAT_R8G8_SSCALED => Format::R8G8_SScaled,
1486            vks::core::VK_FORMAT_R8G8_UINT => Format::R8G8_UInt,
1487            vks::core::VK_FORMAT_R8G8_SINT => Format::R8G8_SInt,
1488            vks::core::VK_FORMAT_R8G8_SRGB => Format::R8G8_sRGB,
1489            vks::core::VK_FORMAT_R8G8B8_UNORM => Format::R8G8B8_UNorm,
1490            vks::core::VK_FORMAT_R8G8B8_SNORM => Format::R8G8B8_SNorm,
1491            vks::core::VK_FORMAT_R8G8B8_USCALED => Format::R8G8B8_UScaled,
1492            vks::core::VK_FORMAT_R8G8B8_SSCALED => Format::R8G8B8_SScaled,
1493            vks::core::VK_FORMAT_R8G8B8_UINT => Format::R8G8B8_UInt,
1494            vks::core::VK_FORMAT_R8G8B8_SINT => Format::R8G8B8_SInt,
1495            vks::core::VK_FORMAT_R8G8B8_SRGB => Format::R8G8B8_sRGB,
1496            vks::core::VK_FORMAT_B8G8R8_UNORM => Format::B8G8R8_UNorm,
1497            vks::core::VK_FORMAT_B8G8R8_SNORM => Format::B8G8R8_SNorm,
1498            vks::core::VK_FORMAT_B8G8R8_USCALED => Format::B8G8R8_UScaled,
1499            vks::core::VK_FORMAT_B8G8R8_SSCALED => Format::B8G8R8_SScaled,
1500            vks::core::VK_FORMAT_B8G8R8_UINT => Format::B8G8R8_UInt,
1501            vks::core::VK_FORMAT_B8G8R8_SINT => Format::B8G8R8_SInt,
1502            vks::core::VK_FORMAT_B8G8R8_SRGB => Format::B8G8R8_sRGB,
1503            vks::core::VK_FORMAT_R8G8B8A8_UNORM => Format::R8G8B8A8_UNorm,
1504            vks::core::VK_FORMAT_R8G8B8A8_SNORM => Format::R8G8B8A8_SNorm,
1505            vks::core::VK_FORMAT_R8G8B8A8_USCALED => Format::R8G8B8A8_UScaled,
1506            vks::core::VK_FORMAT_R8G8B8A8_SSCALED => Format::R8G8B8A8_SScaled,
1507            vks::core::VK_FORMAT_R8G8B8A8_UINT => Format::R8G8B8A8_UInt,
1508            vks::core::VK_FORMAT_R8G8B8A8_SINT => Format::R8G8B8A8_SInt,
1509            vks::core::VK_FORMAT_R8G8B8A8_SRGB => Format::R8G8B8A8_sRGB,
1510            vks::core::VK_FORMAT_B8G8R8A8_UNORM => Format::B8G8R8A8_UNorm,
1511            vks::core::VK_FORMAT_B8G8R8A8_SNORM => Format::B8G8R8A8_SNorm,
1512            vks::core::VK_FORMAT_B8G8R8A8_USCALED => Format::B8G8R8A8_UScaled,
1513            vks::core::VK_FORMAT_B8G8R8A8_SSCALED => Format::B8G8R8A8_SScaled,
1514            vks::core::VK_FORMAT_B8G8R8A8_UINT => Format::B8G8R8A8_UInt,
1515            vks::core::VK_FORMAT_B8G8R8A8_SINT => Format::B8G8R8A8_SInt,
1516            vks::core::VK_FORMAT_B8G8R8A8_SRGB => Format::B8G8R8A8_sRGB,
1517            vks::core::VK_FORMAT_A8B8G8R8_UNORM_PACK32 => Format::A8B8G8R8_UNorm_Pack32,
1518            vks::core::VK_FORMAT_A8B8G8R8_SNORM_PACK32 => Format::A8B8G8R8_SNorm_Pack32,
1519            vks::core::VK_FORMAT_A8B8G8R8_USCALED_PACK32 => Format::A8B8G8R8_UScaled_Pack32,
1520            vks::core::VK_FORMAT_A8B8G8R8_SSCALED_PACK32 => Format::A8B8G8R8_SScaled_Pack32,
1521            vks::core::VK_FORMAT_A8B8G8R8_UINT_PACK32 => Format::A8B8G8R8_UInt_Pack32,
1522            vks::core::VK_FORMAT_A8B8G8R8_SINT_PACK32 => Format::A8B8G8R8_SInt_Pack32,
1523            vks::core::VK_FORMAT_A8B8G8R8_SRGB_PACK32 => Format::A8B8G8R8_sRGB_Pack32,
1524            vks::core::VK_FORMAT_A2R10G10B10_UNORM_PACK32 => Format::A2R10G10B10_UNorm_Pack32,
1525            vks::core::VK_FORMAT_A2R10G10B10_SNORM_PACK32 => Format::A2R10G10B10_SNorm_Pack32,
1526            vks::core::VK_FORMAT_A2R10G10B10_USCALED_PACK32 => Format::A2R10G10B10_UScaled_Pack32,
1527            vks::core::VK_FORMAT_A2R10G10B10_SSCALED_PACK32 => Format::A2R10G10B10_SScaled_Pack32,
1528            vks::core::VK_FORMAT_A2R10G10B10_UINT_PACK32 => Format::A2R10G10B10_UInt_Pack32,
1529            vks::core::VK_FORMAT_A2R10G10B10_SINT_PACK32 => Format::A2R10G10B10_SInt_Pack32,
1530            vks::core::VK_FORMAT_A2B10G10R10_UNORM_PACK32 => Format::A2B10G10R10_UNorm_Pack32,
1531            vks::core::VK_FORMAT_A2B10G10R10_SNORM_PACK32 => Format::A2B10G10R10_SNorm_Pack32,
1532            vks::core::VK_FORMAT_A2B10G10R10_USCALED_PACK32 => Format::A2B10G10R10_UScaled_Pack32,
1533            vks::core::VK_FORMAT_A2B10G10R10_SSCALED_PACK32 => Format::A2B10G10R10_SScaled_Pack32,
1534            vks::core::VK_FORMAT_A2B10G10R10_UINT_PACK32 => Format::A2B10G10R10_UInt_Pack32,
1535            vks::core::VK_FORMAT_A2B10G10R10_SINT_PACK32 => Format::A2B10G10R10_SInt_Pack32,
1536            vks::core::VK_FORMAT_R16_UNORM => Format::R16_UNorm,
1537            vks::core::VK_FORMAT_R16_SNORM => Format::R16_SNorm,
1538            vks::core::VK_FORMAT_R16_USCALED => Format::R16_UScaled,
1539            vks::core::VK_FORMAT_R16_SSCALED => Format::R16_SScaled,
1540            vks::core::VK_FORMAT_R16_UINT => Format::R16_UInt,
1541            vks::core::VK_FORMAT_R16_SINT => Format::R16_SInt,
1542            vks::core::VK_FORMAT_R16_SFLOAT => Format::R16_SFloat,
1543            vks::core::VK_FORMAT_R16G16_UNORM => Format::R16G16_UNorm,
1544            vks::core::VK_FORMAT_R16G16_SNORM => Format::R16G16_SNorm,
1545            vks::core::VK_FORMAT_R16G16_USCALED => Format::R16G16_UScaled,
1546            vks::core::VK_FORMAT_R16G16_SSCALED => Format::R16G16_SScaled,
1547            vks::core::VK_FORMAT_R16G16_UINT => Format::R16G16_UInt,
1548            vks::core::VK_FORMAT_R16G16_SINT => Format::R16G16_SInt,
1549            vks::core::VK_FORMAT_R16G16_SFLOAT => Format::R16G16_SFloat,
1550            vks::core::VK_FORMAT_R16G16B16_UNORM => Format::R16G16B16_UNorm,
1551            vks::core::VK_FORMAT_R16G16B16_SNORM => Format::R16G16B16_SNorm,
1552            vks::core::VK_FORMAT_R16G16B16_USCALED => Format::R16G16B16_UScaled,
1553            vks::core::VK_FORMAT_R16G16B16_SSCALED => Format::R16G16B16_SScaled,
1554            vks::core::VK_FORMAT_R16G16B16_UINT => Format::R16G16B16_UInt,
1555            vks::core::VK_FORMAT_R16G16B16_SINT => Format::R16G16B16_SInt,
1556            vks::core::VK_FORMAT_R16G16B16_SFLOAT => Format::R16G16B16_SFloat,
1557            vks::core::VK_FORMAT_R16G16B16A16_UNORM => Format::R16G16B16A16_UNorm,
1558            vks::core::VK_FORMAT_R16G16B16A16_SNORM => Format::R16G16B16A16_SNorm,
1559            vks::core::VK_FORMAT_R16G16B16A16_USCALED => Format::R16G16B16A16_UScaled,
1560            vks::core::VK_FORMAT_R16G16B16A16_SSCALED => Format::R16G16B16A16_SScaled,
1561            vks::core::VK_FORMAT_R16G16B16A16_UINT => Format::R16G16B16A16_UInt,
1562            vks::core::VK_FORMAT_R16G16B16A16_SINT => Format::R16G16B16A16_SInt,
1563            vks::core::VK_FORMAT_R16G16B16A16_SFLOAT => Format::R16G16B16A16_SFloat,
1564            vks::core::VK_FORMAT_R32_UINT => Format::R32_UInt,
1565            vks::core::VK_FORMAT_R32_SINT => Format::R32_SInt,
1566            vks::core::VK_FORMAT_R32_SFLOAT => Format::R32_SFloat,
1567            vks::core::VK_FORMAT_R32G32_UINT => Format::R32G32_UInt,
1568            vks::core::VK_FORMAT_R32G32_SINT => Format::R32G32_SInt,
1569            vks::core::VK_FORMAT_R32G32_SFLOAT => Format::R32G32_SFloat,
1570            vks::core::VK_FORMAT_R32G32B32_UINT => Format::R32G32B32_UInt,
1571            vks::core::VK_FORMAT_R32G32B32_SINT => Format::R32G32B32_SInt,
1572            vks::core::VK_FORMAT_R32G32B32_SFLOAT => Format::R32G32B32_SFloat,
1573            vks::core::VK_FORMAT_R32G32B32A32_UINT => Format::R32G32B32A32_UInt,
1574            vks::core::VK_FORMAT_R32G32B32A32_SINT => Format::R32G32B32A32_SInt,
1575            vks::core::VK_FORMAT_R32G32B32A32_SFLOAT => Format::R32G32B32A32_SFloat,
1576            vks::core::VK_FORMAT_R64_UINT => Format::R64_UInt,
1577            vks::core::VK_FORMAT_R64_SINT => Format::R64_SInt,
1578            vks::core::VK_FORMAT_R64_SFLOAT => Format::R64_SFloat,
1579            vks::core::VK_FORMAT_R64G64_UINT => Format::R64G64_UInt,
1580            vks::core::VK_FORMAT_R64G64_SINT => Format::R64G64_SInt,
1581            vks::core::VK_FORMAT_R64G64_SFLOAT => Format::R64G64_SFloat,
1582            vks::core::VK_FORMAT_R64G64B64_UINT => Format::R64G64B64_UInt,
1583            vks::core::VK_FORMAT_R64G64B64_SINT => Format::R64G64B64_SInt,
1584            vks::core::VK_FORMAT_R64G64B64_SFLOAT => Format::R64G64B64_SFloat,
1585            vks::core::VK_FORMAT_R64G64B64A64_UINT => Format::R64G64B64A64_UInt,
1586            vks::core::VK_FORMAT_R64G64B64A64_SINT => Format::R64G64B64A64_SInt,
1587            vks::core::VK_FORMAT_R64G64B64A64_SFLOAT => Format::R64G64B64A64_SFloat,
1588            vks::core::VK_FORMAT_B10G11R11_UFLOAT_PACK32 => Format::B10G11R11_UFloat_Pack32,
1589            vks::core::VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 => Format::E5B9G9R9_UFloat_Pack32,
1590            vks::core::VK_FORMAT_D16_UNORM => Format::D16_UNorm,
1591            vks::core::VK_FORMAT_X8_D24_UNORM_PACK32 => Format::X8_D24_UNorm_Pack32,
1592            vks::core::VK_FORMAT_D32_SFLOAT => Format::D32_SFloat,
1593            vks::core::VK_FORMAT_S8_UINT => Format::S8_UInt,
1594            vks::core::VK_FORMAT_D16_UNORM_S8_UINT => Format::D16_UNorm_S8_UInt,
1595            vks::core::VK_FORMAT_D24_UNORM_S8_UINT => Format::D24_UNorm_S8_UInt,
1596            vks::core::VK_FORMAT_D32_SFLOAT_S8_UINT => Format::D32_SFloat_S8_UInt,
1597            vks::core::VK_FORMAT_BC1_RGB_UNORM_BLOCK => Format::BC1_RGB_UNorm_Block,
1598            vks::core::VK_FORMAT_BC1_RGB_SRGB_BLOCK => Format::BC1_RGB_sRGB_Block,
1599            vks::core::VK_FORMAT_BC1_RGBA_UNORM_BLOCK => Format::BC1_RGBA_UNorm_Block,
1600            vks::core::VK_FORMAT_BC1_RGBA_SRGB_BLOCK => Format::BC1_RGBA_sRGB_Block,
1601            vks::core::VK_FORMAT_BC2_UNORM_BLOCK => Format::BC2_UNorm_Block,
1602            vks::core::VK_FORMAT_BC2_SRGB_BLOCK => Format::BC2_sRGB_Block,
1603            vks::core::VK_FORMAT_BC3_UNORM_BLOCK => Format::BC3_UNorm_Block,
1604            vks::core::VK_FORMAT_BC3_SRGB_BLOCK => Format::BC3_sRGB_Block,
1605            vks::core::VK_FORMAT_BC4_UNORM_BLOCK => Format::BC4_UNorm_Block,
1606            vks::core::VK_FORMAT_BC4_SNORM_BLOCK => Format::BC4_SNorm_Block,
1607            vks::core::VK_FORMAT_BC5_UNORM_BLOCK => Format::BC5_UNorm_Block,
1608            vks::core::VK_FORMAT_BC5_SNORM_BLOCK => Format::BC5_SNorm_Block,
1609            vks::core::VK_FORMAT_BC6H_UFLOAT_BLOCK => Format::BC6H_UFloat_Block,
1610            vks::core::VK_FORMAT_BC6H_SFLOAT_BLOCK => Format::BC6H_SFloat_Block,
1611            vks::core::VK_FORMAT_BC7_UNORM_BLOCK => Format::BC7_UNorm_Block,
1612            vks::core::VK_FORMAT_BC7_SRGB_BLOCK => Format::BC7_sRGB_Block,
1613            vks::core::VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK => Format::ETC2_R8G8B8_UNorm_Block,
1614            vks::core::VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK => Format::ETC2_R8G8B8_sRGB_Block,
1615            vks::core::VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK => Format::ETC2_R8G8B8A1_UNorm_Block,
1616            vks::core::VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK => Format::ETC2_R8G8B8A1_sRGB_Block,
1617            vks::core::VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK => Format::ETC2_R8G8B8A8_UNorm_Block,
1618            vks::core::VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK => Format::ETC2_R8G8B8A8_sRGB_Block,
1619            vks::core::VK_FORMAT_EAC_R11_UNORM_BLOCK => Format::EAC_R11_UNorm_Block,
1620            vks::core::VK_FORMAT_EAC_R11_SNORM_BLOCK => Format::EAC_R11_SNorm_Block,
1621            vks::core::VK_FORMAT_EAC_R11G11_UNORM_BLOCK => Format::EAC_R11G11_UNorm_Block,
1622            vks::core::VK_FORMAT_EAC_R11G11_SNORM_BLOCK => Format::EAC_R11G11_SNorm_Block,
1623            vks::core::VK_FORMAT_ASTC_4x4_UNORM_BLOCK => Format::ASTC_4x4_UNorm_Block,
1624            vks::core::VK_FORMAT_ASTC_4x4_SRGB_BLOCK => Format::ASTC_4x4_sRGB_Block,
1625            vks::core::VK_FORMAT_ASTC_5x4_UNORM_BLOCK => Format::ASTC_5x4_UNorm_Block,
1626            vks::core::VK_FORMAT_ASTC_5x4_SRGB_BLOCK => Format::ASTC_5x4_sRGB_Block,
1627            vks::core::VK_FORMAT_ASTC_5x5_UNORM_BLOCK => Format::ASTC_5x5_UNorm_Block,
1628            vks::core::VK_FORMAT_ASTC_5x5_SRGB_BLOCK => Format::ASTC_5x5_sRGB_Block,
1629            vks::core::VK_FORMAT_ASTC_6x5_UNORM_BLOCK => Format::ASTC_6x5_UNorm_Block,
1630            vks::core::VK_FORMAT_ASTC_6x5_SRGB_BLOCK => Format::ASTC_6x5_sRGB_Block,
1631            vks::core::VK_FORMAT_ASTC_6x6_UNORM_BLOCK => Format::ASTC_6x6_UNorm_Block,
1632            vks::core::VK_FORMAT_ASTC_6x6_SRGB_BLOCK => Format::ASTC_6x6_sRGB_Block,
1633            vks::core::VK_FORMAT_ASTC_8x5_UNORM_BLOCK => Format::ASTC_8x5_UNorm_Block,
1634            vks::core::VK_FORMAT_ASTC_8x5_SRGB_BLOCK => Format::ASTC_8x5_sRGB_Block,
1635            vks::core::VK_FORMAT_ASTC_8x6_UNORM_BLOCK => Format::ASTC_8x6_UNorm_Block,
1636            vks::core::VK_FORMAT_ASTC_8x6_SRGB_BLOCK => Format::ASTC_8x6_sRGB_Block,
1637            vks::core::VK_FORMAT_ASTC_8x8_UNORM_BLOCK => Format::ASTC_8x8_UNorm_Block,
1638            vks::core::VK_FORMAT_ASTC_8x8_SRGB_BLOCK => Format::ASTC_8x8_sRGB_Block,
1639            vks::core::VK_FORMAT_ASTC_10x5_UNORM_BLOCK => Format::ASTC_10x5_UNorm_Block,
1640            vks::core::VK_FORMAT_ASTC_10x5_SRGB_BLOCK => Format::ASTC_10x5_sRGB_Block,
1641            vks::core::VK_FORMAT_ASTC_10x6_UNORM_BLOCK => Format::ASTC_10x6_UNorm_Block,
1642            vks::core::VK_FORMAT_ASTC_10x6_SRGB_BLOCK => Format::ASTC_10x6_sRGB_Block,
1643            vks::core::VK_FORMAT_ASTC_10x8_UNORM_BLOCK => Format::ASTC_10x8_UNorm_Block,
1644            vks::core::VK_FORMAT_ASTC_10x8_SRGB_BLOCK => Format::ASTC_10x8_sRGB_Block,
1645            vks::core::VK_FORMAT_ASTC_10x10_UNORM_BLOCK => Format::ASTC_10x10_UNorm_Block,
1646            vks::core::VK_FORMAT_ASTC_10x10_SRGB_BLOCK => Format::ASTC_10x10_sRGB_Block,
1647            vks::core::VK_FORMAT_ASTC_12x10_UNORM_BLOCK => Format::ASTC_12x10_UNorm_Block,
1648            vks::core::VK_FORMAT_ASTC_12x10_SRGB_BLOCK => Format::ASTC_12x10_sRGB_Block,
1649            vks::core::VK_FORMAT_ASTC_12x12_UNORM_BLOCK => Format::ASTC_12x12_UNorm_Block,
1650            vks::core::VK_FORMAT_ASTC_12x12_SRGB_BLOCK => Format::ASTC_12x12_sRGB_Block,
1651            vks::core::VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG => Format::PVRTC1_2BPP_UNorm_Block_Img,
1652            vks::core::VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG => Format::PVRTC1_4BPP_UNorm_Block_Img,
1653            vks::core::VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG => Format::PVRTC2_2BPP_UNorm_Block_Img,
1654            vks::core::VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG => Format::PVRTC2_4BPP_UNorm_Block_Img,
1655            vks::core::VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG => Format::PVRTC1_2BPP_sRGB_Block_Img,
1656            vks::core::VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG => Format::PVRTC1_4BPP_sRGB_Block_Img,
1657            vks::core::VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG => Format::PVRTC2_2BPP_sRGB_Block_Img,
1658            vks::core::VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG => Format::PVRTC2_4BPP_sRGB_Block_Img,
1659            _ => Format::Unknown(format),
1660        }
1661    }
1662}
1663
1664impl From<Format> for vks::core::VkFormat {
1665    fn from(format: Format) -> Self {
1666        match format {
1667            Format::Undefined => vks::core::VK_FORMAT_UNDEFINED,
1668            Format::R4G4_UNorm_Pack8 => vks::core::VK_FORMAT_R4G4_UNORM_PACK8,
1669            Format::R4G4B4A4_UNorm_Pack16 => vks::core::VK_FORMAT_R4G4B4A4_UNORM_PACK16,
1670            Format::B4G4R4A4_UNorm_Pack16 => vks::core::VK_FORMAT_B4G4R4A4_UNORM_PACK16,
1671            Format::R5G6B5_UNorm_Pack16 => vks::core::VK_FORMAT_R5G6B5_UNORM_PACK16,
1672            Format::B5G6R5_UNorm_Pack16 => vks::core::VK_FORMAT_B5G6R5_UNORM_PACK16,
1673            Format::R5G5B5A1_UNorm_Pack16 => vks::core::VK_FORMAT_R5G5B5A1_UNORM_PACK16,
1674            Format::B5G5R5A1_UNorm_Pack16 => vks::core::VK_FORMAT_B5G5R5A1_UNORM_PACK16,
1675            Format::A1R5G5B5_UNorm_Pack16 => vks::core::VK_FORMAT_A1R5G5B5_UNORM_PACK16,
1676            Format::R8_UNorm => vks::core::VK_FORMAT_R8_UNORM,
1677            Format::R8_SNorm => vks::core::VK_FORMAT_R8_SNORM,
1678            Format::R8_UScaled => vks::core::VK_FORMAT_R8_USCALED,
1679            Format::R8_SScaled => vks::core::VK_FORMAT_R8_SSCALED,
1680            Format::R8_UInt => vks::core::VK_FORMAT_R8_UINT,
1681            Format::R8_SInt => vks::core::VK_FORMAT_R8_SINT,
1682            Format::R8_sRGB => vks::core::VK_FORMAT_R8_SRGB,
1683            Format::R8G8_UNorm => vks::core::VK_FORMAT_R8G8_UNORM,
1684            Format::R8G8_SNorm => vks::core::VK_FORMAT_R8G8_SNORM,
1685            Format::R8G8_UScaled => vks::core::VK_FORMAT_R8G8_USCALED,
1686            Format::R8G8_SScaled => vks::core::VK_FORMAT_R8G8_SSCALED,
1687            Format::R8G8_UInt => vks::core::VK_FORMAT_R8G8_UINT,
1688            Format::R8G8_SInt => vks::core::VK_FORMAT_R8G8_SINT,
1689            Format::R8G8_sRGB => vks::core::VK_FORMAT_R8G8_SRGB,
1690            Format::R8G8B8_UNorm => vks::core::VK_FORMAT_R8G8B8_UNORM,
1691            Format::R8G8B8_SNorm => vks::core::VK_FORMAT_R8G8B8_SNORM,
1692            Format::R8G8B8_UScaled => vks::core::VK_FORMAT_R8G8B8_USCALED,
1693            Format::R8G8B8_SScaled => vks::core::VK_FORMAT_R8G8B8_SSCALED,
1694            Format::R8G8B8_UInt => vks::core::VK_FORMAT_R8G8B8_UINT,
1695            Format::R8G8B8_SInt => vks::core::VK_FORMAT_R8G8B8_SINT,
1696            Format::R8G8B8_sRGB => vks::core::VK_FORMAT_R8G8B8_SRGB,
1697            Format::B8G8R8_UNorm => vks::core::VK_FORMAT_B8G8R8_UNORM,
1698            Format::B8G8R8_SNorm => vks::core::VK_FORMAT_B8G8R8_SNORM,
1699            Format::B8G8R8_UScaled => vks::core::VK_FORMAT_B8G8R8_USCALED,
1700            Format::B8G8R8_SScaled => vks::core::VK_FORMAT_B8G8R8_SSCALED,
1701            Format::B8G8R8_UInt => vks::core::VK_FORMAT_B8G8R8_UINT,
1702            Format::B8G8R8_SInt => vks::core::VK_FORMAT_B8G8R8_SINT,
1703            Format::B8G8R8_sRGB => vks::core::VK_FORMAT_B8G8R8_SRGB,
1704            Format::R8G8B8A8_UNorm => vks::core::VK_FORMAT_R8G8B8A8_UNORM,
1705            Format::R8G8B8A8_SNorm => vks::core::VK_FORMAT_R8G8B8A8_SNORM,
1706            Format::R8G8B8A8_UScaled => vks::core::VK_FORMAT_R8G8B8A8_USCALED,
1707            Format::R8G8B8A8_SScaled => vks::core::VK_FORMAT_R8G8B8A8_SSCALED,
1708            Format::R8G8B8A8_UInt => vks::core::VK_FORMAT_R8G8B8A8_UINT,
1709            Format::R8G8B8A8_SInt => vks::core::VK_FORMAT_R8G8B8A8_SINT,
1710            Format::R8G8B8A8_sRGB => vks::core::VK_FORMAT_R8G8B8A8_SRGB,
1711            Format::B8G8R8A8_UNorm => vks::core::VK_FORMAT_B8G8R8A8_UNORM,
1712            Format::B8G8R8A8_SNorm => vks::core::VK_FORMAT_B8G8R8A8_SNORM,
1713            Format::B8G8R8A8_UScaled => vks::core::VK_FORMAT_B8G8R8A8_USCALED,
1714            Format::B8G8R8A8_SScaled => vks::core::VK_FORMAT_B8G8R8A8_SSCALED,
1715            Format::B8G8R8A8_UInt => vks::core::VK_FORMAT_B8G8R8A8_UINT,
1716            Format::B8G8R8A8_SInt => vks::core::VK_FORMAT_B8G8R8A8_SINT,
1717            Format::B8G8R8A8_sRGB => vks::core::VK_FORMAT_B8G8R8A8_SRGB,
1718            Format::A8B8G8R8_UNorm_Pack32 => vks::core::VK_FORMAT_A8B8G8R8_UNORM_PACK32,
1719            Format::A8B8G8R8_SNorm_Pack32 => vks::core::VK_FORMAT_A8B8G8R8_SNORM_PACK32,
1720            Format::A8B8G8R8_UScaled_Pack32 => vks::core::VK_FORMAT_A8B8G8R8_USCALED_PACK32,
1721            Format::A8B8G8R8_SScaled_Pack32 => vks::core::VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
1722            Format::A8B8G8R8_UInt_Pack32 => vks::core::VK_FORMAT_A8B8G8R8_UINT_PACK32,
1723            Format::A8B8G8R8_SInt_Pack32 => vks::core::VK_FORMAT_A8B8G8R8_SINT_PACK32,
1724            Format::A8B8G8R8_sRGB_Pack32 => vks::core::VK_FORMAT_A8B8G8R8_SRGB_PACK32,
1725            Format::A2R10G10B10_UNorm_Pack32 => vks::core::VK_FORMAT_A2R10G10B10_UNORM_PACK32,
1726            Format::A2R10G10B10_SNorm_Pack32 => vks::core::VK_FORMAT_A2R10G10B10_SNORM_PACK32,
1727            Format::A2R10G10B10_UScaled_Pack32 => vks::core::VK_FORMAT_A2R10G10B10_USCALED_PACK32,
1728            Format::A2R10G10B10_SScaled_Pack32 => vks::core::VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
1729            Format::A2R10G10B10_UInt_Pack32 => vks::core::VK_FORMAT_A2R10G10B10_UINT_PACK32,
1730            Format::A2R10G10B10_SInt_Pack32 => vks::core::VK_FORMAT_A2R10G10B10_SINT_PACK32,
1731            Format::A2B10G10R10_UNorm_Pack32 => vks::core::VK_FORMAT_A2B10G10R10_UNORM_PACK32,
1732            Format::A2B10G10R10_SNorm_Pack32 => vks::core::VK_FORMAT_A2B10G10R10_SNORM_PACK32,
1733            Format::A2B10G10R10_UScaled_Pack32 => vks::core::VK_FORMAT_A2B10G10R10_USCALED_PACK32,
1734            Format::A2B10G10R10_SScaled_Pack32 => vks::core::VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
1735            Format::A2B10G10R10_UInt_Pack32 => vks::core::VK_FORMAT_A2B10G10R10_UINT_PACK32,
1736            Format::A2B10G10R10_SInt_Pack32 => vks::core::VK_FORMAT_A2B10G10R10_SINT_PACK32,
1737            Format::R16_UNorm => vks::core::VK_FORMAT_R16_UNORM,
1738            Format::R16_SNorm => vks::core::VK_FORMAT_R16_SNORM,
1739            Format::R16_UScaled => vks::core::VK_FORMAT_R16_USCALED,
1740            Format::R16_SScaled => vks::core::VK_FORMAT_R16_SSCALED,
1741            Format::R16_UInt => vks::core::VK_FORMAT_R16_UINT,
1742            Format::R16_SInt => vks::core::VK_FORMAT_R16_SINT,
1743            Format::R16_SFloat => vks::core::VK_FORMAT_R16_SFLOAT,
1744            Format::R16G16_UNorm => vks::core::VK_FORMAT_R16G16_UNORM,
1745            Format::R16G16_SNorm => vks::core::VK_FORMAT_R16G16_SNORM,
1746            Format::R16G16_UScaled => vks::core::VK_FORMAT_R16G16_USCALED,
1747            Format::R16G16_SScaled => vks::core::VK_FORMAT_R16G16_SSCALED,
1748            Format::R16G16_UInt => vks::core::VK_FORMAT_R16G16_UINT,
1749            Format::R16G16_SInt => vks::core::VK_FORMAT_R16G16_SINT,
1750            Format::R16G16_SFloat => vks::core::VK_FORMAT_R16G16_SFLOAT,
1751            Format::R16G16B16_UNorm => vks::core::VK_FORMAT_R16G16B16_UNORM,
1752            Format::R16G16B16_SNorm => vks::core::VK_FORMAT_R16G16B16_SNORM,
1753            Format::R16G16B16_UScaled => vks::core::VK_FORMAT_R16G16B16_USCALED,
1754            Format::R16G16B16_SScaled => vks::core::VK_FORMAT_R16G16B16_SSCALED,
1755            Format::R16G16B16_UInt => vks::core::VK_FORMAT_R16G16B16_UINT,
1756            Format::R16G16B16_SInt => vks::core::VK_FORMAT_R16G16B16_SINT,
1757            Format::R16G16B16_SFloat => vks::core::VK_FORMAT_R16G16B16_SFLOAT,
1758            Format::R16G16B16A16_UNorm => vks::core::VK_FORMAT_R16G16B16A16_UNORM,
1759            Format::R16G16B16A16_SNorm => vks::core::VK_FORMAT_R16G16B16A16_SNORM,
1760            Format::R16G16B16A16_UScaled => vks::core::VK_FORMAT_R16G16B16A16_USCALED,
1761            Format::R16G16B16A16_SScaled => vks::core::VK_FORMAT_R16G16B16A16_SSCALED,
1762            Format::R16G16B16A16_UInt => vks::core::VK_FORMAT_R16G16B16A16_UINT,
1763            Format::R16G16B16A16_SInt => vks::core::VK_FORMAT_R16G16B16A16_SINT,
1764            Format::R16G16B16A16_SFloat => vks::core::VK_FORMAT_R16G16B16A16_SFLOAT,
1765            Format::R32_UInt => vks::core::VK_FORMAT_R32_UINT,
1766            Format::R32_SInt => vks::core::VK_FORMAT_R32_SINT,
1767            Format::R32_SFloat => vks::core::VK_FORMAT_R32_SFLOAT,
1768            Format::R32G32_UInt => vks::core::VK_FORMAT_R32G32_UINT,
1769            Format::R32G32_SInt => vks::core::VK_FORMAT_R32G32_SINT,
1770            Format::R32G32_SFloat => vks::core::VK_FORMAT_R32G32_SFLOAT,
1771            Format::R32G32B32_UInt => vks::core::VK_FORMAT_R32G32B32_UINT,
1772            Format::R32G32B32_SInt => vks::core::VK_FORMAT_R32G32B32_SINT,
1773            Format::R32G32B32_SFloat => vks::core::VK_FORMAT_R32G32B32_SFLOAT,
1774            Format::R32G32B32A32_UInt => vks::core::VK_FORMAT_R32G32B32A32_UINT,
1775            Format::R32G32B32A32_SInt => vks::core::VK_FORMAT_R32G32B32A32_SINT,
1776            Format::R32G32B32A32_SFloat => vks::core::VK_FORMAT_R32G32B32A32_SFLOAT,
1777            Format::R64_UInt => vks::core::VK_FORMAT_R64_UINT,
1778            Format::R64_SInt => vks::core::VK_FORMAT_R64_SINT,
1779            Format::R64_SFloat => vks::core::VK_FORMAT_R64_SFLOAT,
1780            Format::R64G64_UInt => vks::core::VK_FORMAT_R64G64_UINT,
1781            Format::R64G64_SInt => vks::core::VK_FORMAT_R64G64_SINT,
1782            Format::R64G64_SFloat => vks::core::VK_FORMAT_R64G64_SFLOAT,
1783            Format::R64G64B64_UInt => vks::core::VK_FORMAT_R64G64B64_UINT,
1784            Format::R64G64B64_SInt => vks::core::VK_FORMAT_R64G64B64_SINT,
1785            Format::R64G64B64_SFloat => vks::core::VK_FORMAT_R64G64B64_SFLOAT,
1786            Format::R64G64B64A64_UInt => vks::core::VK_FORMAT_R64G64B64A64_UINT,
1787            Format::R64G64B64A64_SInt => vks::core::VK_FORMAT_R64G64B64A64_SINT,
1788            Format::R64G64B64A64_SFloat => vks::core::VK_FORMAT_R64G64B64A64_SFLOAT,
1789            Format::B10G11R11_UFloat_Pack32 => vks::core::VK_FORMAT_B10G11R11_UFLOAT_PACK32,
1790            Format::E5B9G9R9_UFloat_Pack32 => vks::core::VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
1791            Format::D16_UNorm => vks::core::VK_FORMAT_D16_UNORM,
1792            Format::X8_D24_UNorm_Pack32 => vks::core::VK_FORMAT_X8_D24_UNORM_PACK32,
1793            Format::D32_SFloat => vks::core::VK_FORMAT_D32_SFLOAT,
1794            Format::S8_UInt => vks::core::VK_FORMAT_S8_UINT,
1795            Format::D16_UNorm_S8_UInt => vks::core::VK_FORMAT_D16_UNORM_S8_UINT,
1796            Format::D24_UNorm_S8_UInt => vks::core::VK_FORMAT_D24_UNORM_S8_UINT,
1797            Format::D32_SFloat_S8_UInt => vks::core::VK_FORMAT_D32_SFLOAT_S8_UINT,
1798            Format::BC1_RGB_UNorm_Block => vks::core::VK_FORMAT_BC1_RGB_UNORM_BLOCK,
1799            Format::BC1_RGB_sRGB_Block => vks::core::VK_FORMAT_BC1_RGB_SRGB_BLOCK,
1800            Format::BC1_RGBA_UNorm_Block => vks::core::VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
1801            Format::BC1_RGBA_sRGB_Block => vks::core::VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
1802            Format::BC2_UNorm_Block => vks::core::VK_FORMAT_BC2_UNORM_BLOCK,
1803            Format::BC2_sRGB_Block => vks::core::VK_FORMAT_BC2_SRGB_BLOCK,
1804            Format::BC3_UNorm_Block => vks::core::VK_FORMAT_BC3_UNORM_BLOCK,
1805            Format::BC3_sRGB_Block => vks::core::VK_FORMAT_BC3_SRGB_BLOCK,
1806            Format::BC4_UNorm_Block => vks::core::VK_FORMAT_BC4_UNORM_BLOCK,
1807            Format::BC4_SNorm_Block => vks::core::VK_FORMAT_BC4_SNORM_BLOCK,
1808            Format::BC5_UNorm_Block => vks::core::VK_FORMAT_BC5_UNORM_BLOCK,
1809            Format::BC5_SNorm_Block => vks::core::VK_FORMAT_BC5_SNORM_BLOCK,
1810            Format::BC6H_UFloat_Block => vks::core::VK_FORMAT_BC6H_UFLOAT_BLOCK,
1811            Format::BC6H_SFloat_Block => vks::core::VK_FORMAT_BC6H_SFLOAT_BLOCK,
1812            Format::BC7_UNorm_Block => vks::core::VK_FORMAT_BC7_UNORM_BLOCK,
1813            Format::BC7_sRGB_Block => vks::core::VK_FORMAT_BC7_SRGB_BLOCK,
1814            Format::ETC2_R8G8B8_UNorm_Block => vks::core::VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
1815            Format::ETC2_R8G8B8_sRGB_Block => vks::core::VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
1816            Format::ETC2_R8G8B8A1_UNorm_Block => vks::core::VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
1817            Format::ETC2_R8G8B8A1_sRGB_Block => vks::core::VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
1818            Format::ETC2_R8G8B8A8_UNorm_Block => vks::core::VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
1819            Format::ETC2_R8G8B8A8_sRGB_Block => vks::core::VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
1820            Format::EAC_R11_UNorm_Block => vks::core::VK_FORMAT_EAC_R11_UNORM_BLOCK,
1821            Format::EAC_R11_SNorm_Block => vks::core::VK_FORMAT_EAC_R11_SNORM_BLOCK,
1822            Format::EAC_R11G11_UNorm_Block => vks::core::VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
1823            Format::EAC_R11G11_SNorm_Block => vks::core::VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
1824            Format::ASTC_4x4_UNorm_Block => vks::core::VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
1825            Format::ASTC_4x4_sRGB_Block => vks::core::VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
1826            Format::ASTC_5x4_UNorm_Block => vks::core::VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
1827            Format::ASTC_5x4_sRGB_Block => vks::core::VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
1828            Format::ASTC_5x5_UNorm_Block => vks::core::VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
1829            Format::ASTC_5x5_sRGB_Block => vks::core::VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
1830            Format::ASTC_6x5_UNorm_Block => vks::core::VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
1831            Format::ASTC_6x5_sRGB_Block => vks::core::VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
1832            Format::ASTC_6x6_UNorm_Block => vks::core::VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
1833            Format::ASTC_6x6_sRGB_Block => vks::core::VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
1834            Format::ASTC_8x5_UNorm_Block => vks::core::VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
1835            Format::ASTC_8x5_sRGB_Block => vks::core::VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
1836            Format::ASTC_8x6_UNorm_Block => vks::core::VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
1837            Format::ASTC_8x6_sRGB_Block => vks::core::VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
1838            Format::ASTC_8x8_UNorm_Block => vks::core::VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
1839            Format::ASTC_8x8_sRGB_Block => vks::core::VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
1840            Format::ASTC_10x5_UNorm_Block => vks::core::VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
1841            Format::ASTC_10x5_sRGB_Block => vks::core::VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
1842            Format::ASTC_10x6_UNorm_Block => vks::core::VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
1843            Format::ASTC_10x6_sRGB_Block => vks::core::VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
1844            Format::ASTC_10x8_UNorm_Block => vks::core::VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
1845            Format::ASTC_10x8_sRGB_Block => vks::core::VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
1846            Format::ASTC_10x10_UNorm_Block => vks::core::VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
1847            Format::ASTC_10x10_sRGB_Block => vks::core::VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
1848            Format::ASTC_12x10_UNorm_Block => vks::core::VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
1849            Format::ASTC_12x10_sRGB_Block => vks::core::VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
1850            Format::ASTC_12x12_UNorm_Block => vks::core::VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
1851            Format::ASTC_12x12_sRGB_Block => vks::core::VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
1852            Format::PVRTC1_2BPP_UNorm_Block_Img => vks::core::VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
1853            Format::PVRTC1_4BPP_UNorm_Block_Img => vks::core::VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
1854            Format::PVRTC2_2BPP_UNorm_Block_Img => vks::core::VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
1855            Format::PVRTC2_4BPP_UNorm_Block_Img => vks::core::VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG,
1856            Format::PVRTC1_2BPP_sRGB_Block_Img => vks::core::VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
1857            Format::PVRTC1_4BPP_sRGB_Block_Img => vks::core::VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
1858            Format::PVRTC2_2BPP_sRGB_Block_Img => vks::core::VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
1859            Format::PVRTC2_4BPP_sRGB_Block_Img => vks::core::VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
1860            Format::Unknown(format) => format,
1861        }
1862    }
1863}
1864
1865/// See [`VkImageType`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageType)
1866#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1867pub enum ImageType {
1868    Type1D,
1869    Type2D,
1870    Type3D,
1871    Unknown(vks::core::VkImageType),
1872}
1873
1874impl From<ImageType> for vks::core::VkImageType {
1875    fn from(image_type: ImageType) -> Self {
1876        match image_type {
1877            ImageType::Type1D => vks::core::VK_IMAGE_TYPE_1D,
1878            ImageType::Type2D => vks::core::VK_IMAGE_TYPE_2D,
1879            ImageType::Type3D => vks::core::VK_IMAGE_TYPE_3D,
1880            ImageType::Unknown(image_type) => image_type,
1881        }
1882    }
1883}
1884
1885impl From<vks::core::VkImageType> for ImageType {
1886    fn from(image_type: vks::core::VkImageType) -> Self {
1887        match image_type {
1888            vks::core::VK_IMAGE_TYPE_1D => ImageType::Type1D,
1889            vks::core::VK_IMAGE_TYPE_2D => ImageType::Type2D,
1890            vks::core::VK_IMAGE_TYPE_3D => ImageType::Type3D,
1891            _ => ImageType::Unknown(image_type),
1892        }
1893    }
1894}
1895
1896/// See [`VkImageTiling`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageTiling)
1897#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1898pub enum ImageTiling {
1899    Optimal,
1900    Linear,
1901    Unknown(vks::core::VkImageTiling),
1902}
1903
1904impl From<ImageTiling> for vks::core::VkImageTiling {
1905    fn from(tiling: ImageTiling) -> Self {
1906        match tiling {
1907            ImageTiling::Optimal => vks::core::VK_IMAGE_TILING_OPTIMAL,
1908            ImageTiling::Linear => vks::core::VK_IMAGE_TILING_LINEAR,
1909            ImageTiling::Unknown(tiling) => tiling,
1910        }
1911    }
1912}
1913
1914impl From<vks::core::VkImageTiling> for ImageTiling {
1915    fn from(tiling: vks::core::VkImageTiling) -> Self {
1916        match tiling {
1917            vks::core::VK_IMAGE_TILING_OPTIMAL => ImageTiling::Optimal,
1918            vks::core::VK_IMAGE_TILING_LINEAR => ImageTiling::Linear,
1919            _ => ImageTiling::Unknown(tiling),
1920        }
1921    }
1922}
1923
1924/// See [`VkPhysicalDeviceType`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPhysicalDeviceType)
1925#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1926pub enum PhysicalDeviceType {
1927    Other,
1928    IntegratedGpu,
1929    DiscreteGpu,
1930    VirtualGpu,
1931    Cpu,
1932    Unknown(vks::core::VkPhysicalDeviceType),
1933}
1934
1935impl From<vks::core::VkPhysicalDeviceType> for PhysicalDeviceType {
1936    fn from(physical_device_type: vks::core::VkPhysicalDeviceType) -> Self {
1937        match physical_device_type {
1938            vks::core::VK_PHYSICAL_DEVICE_TYPE_OTHER => PhysicalDeviceType::Other,
1939            vks::core::VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU => PhysicalDeviceType::IntegratedGpu,
1940            vks::core::VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU => PhysicalDeviceType::DiscreteGpu,
1941            vks::core::VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU => PhysicalDeviceType::VirtualGpu,
1942            vks::core::VK_PHYSICAL_DEVICE_TYPE_CPU => PhysicalDeviceType::Cpu,
1943            _ => PhysicalDeviceType::Unknown(physical_device_type),
1944        }
1945    }
1946}
1947
1948impl From<PhysicalDeviceType> for vks::core::VkPhysicalDeviceType {
1949    fn from(physical_device_type: PhysicalDeviceType) -> Self {
1950        match physical_device_type {
1951            PhysicalDeviceType::Other => vks::core::VK_PHYSICAL_DEVICE_TYPE_OTHER,
1952            PhysicalDeviceType::IntegratedGpu => vks::core::VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
1953            PhysicalDeviceType::DiscreteGpu => vks::core::VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
1954            PhysicalDeviceType::VirtualGpu => vks::core::VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
1955            PhysicalDeviceType::Cpu => vks::core::VK_PHYSICAL_DEVICE_TYPE_CPU,
1956            PhysicalDeviceType::Unknown(physical_device_type) => physical_device_type,
1957        }
1958    }
1959}
1960
1961/// See [`VkQueryType`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkQueryType)
1962#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1963pub enum QueryType {
1964    Occlusion,
1965    PipelineStatistics,
1966    Timestamp,
1967    Unknown(vks::core::VkQueryType),
1968}
1969
1970impl From<QueryType> for vks::core::VkQueryType {
1971    fn from(query_type: QueryType) -> Self {
1972        match query_type {
1973            QueryType::Occlusion => vks::core::VK_QUERY_TYPE_OCCLUSION,
1974            QueryType::PipelineStatistics => vks::core::VK_QUERY_TYPE_PIPELINE_STATISTICS,
1975            QueryType::Timestamp => vks::core::VK_QUERY_TYPE_TIMESTAMP,
1976            QueryType::Unknown(query_type) => query_type,
1977        }
1978    }
1979}
1980
1981/// See [`VkSharingMode`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSharingMode)
1982#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1983pub enum SharingMode {
1984    Exclusive,
1985    Concurrent,
1986    Unknown(vks::core::VkSharingMode),
1987}
1988
1989impl From<SharingMode> for vks::core::VkSharingMode {
1990    fn from(mode: SharingMode) -> Self {
1991        match mode {
1992            SharingMode::Exclusive => vks::core::VK_SHARING_MODE_EXCLUSIVE,
1993            SharingMode::Concurrent => vks::core::VK_SHARING_MODE_CONCURRENT,
1994            SharingMode::Unknown(mode) => mode,
1995        }
1996    }
1997}
1998
1999impl From<vks::core::VkSharingMode> for SharingMode {
2000    fn from(mode: vks::core::VkSharingMode) -> Self {
2001        match mode {
2002            vks::core::VK_SHARING_MODE_EXCLUSIVE => SharingMode::Exclusive,
2003            vks::core::VK_SHARING_MODE_CONCURRENT => SharingMode::Concurrent,
2004            _ => SharingMode::Unknown(mode),
2005        }
2006    }
2007}
2008
2009/// See [`VkImageLayout`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageLayout)
2010#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2011pub enum ImageLayout {
2012    Undefined,
2013    General,
2014    ColorAttachmentOptimal,
2015    DepthStencilAttachmentOptimal,
2016    DepthStencilReadOnlyOptimal,
2017    ShaderReadOnlyOptimal,
2018    TransferSrcOptimal,
2019    TransferDstOptimal,
2020    Preinitialized,
2021
2022    /// See extension [`VK_KHR_swapchain`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_KHR_swapchain)
2023    PresentSrcKhr,
2024
2025    Unknown(vks::core::VkImageLayout),
2026}
2027
2028impl From<ImageLayout> for vks::core::VkImageLayout {
2029    fn from(layout: ImageLayout) -> Self {
2030        match layout {
2031            ImageLayout::Undefined => vks::core::VK_IMAGE_LAYOUT_UNDEFINED,
2032            ImageLayout::General => vks::core::VK_IMAGE_LAYOUT_GENERAL,
2033            ImageLayout::ColorAttachmentOptimal => vks::core::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
2034            ImageLayout::DepthStencilAttachmentOptimal => vks::core::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
2035            ImageLayout::DepthStencilReadOnlyOptimal => vks::core::VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
2036            ImageLayout::ShaderReadOnlyOptimal => vks::core::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
2037            ImageLayout::TransferSrcOptimal => vks::core::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2038            ImageLayout::TransferDstOptimal => vks::core::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
2039            ImageLayout::Preinitialized => vks::core::VK_IMAGE_LAYOUT_PREINITIALIZED,
2040            ImageLayout::PresentSrcKhr => vks::core::VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
2041            ImageLayout::Unknown(layout) => layout,
2042        }
2043    }
2044}
2045
2046impl From<vks::core::VkImageLayout> for ImageLayout {
2047    fn from(layout: vks::core::VkImageLayout) -> Self {
2048        match layout {
2049            vks::core::VK_IMAGE_LAYOUT_UNDEFINED => ImageLayout::Undefined,
2050            vks::core::VK_IMAGE_LAYOUT_GENERAL => ImageLayout::General,
2051            vks::core::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL => ImageLayout::ColorAttachmentOptimal,
2052            vks::core::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL => ImageLayout::DepthStencilAttachmentOptimal,
2053            vks::core::VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL => ImageLayout::DepthStencilReadOnlyOptimal,
2054            vks::core::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL => ImageLayout::ShaderReadOnlyOptimal,
2055            vks::core::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL => ImageLayout::TransferSrcOptimal,
2056            vks::core::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL => ImageLayout::TransferDstOptimal,
2057            vks::core::VK_IMAGE_LAYOUT_PREINITIALIZED => ImageLayout::Preinitialized,
2058            vks::core::VK_IMAGE_LAYOUT_PRESENT_SRC_KHR => ImageLayout::PresentSrcKhr,
2059            _ => ImageLayout::Unknown(layout),
2060        }
2061    }
2062}
2063
2064/// See [`VkImageViewType`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageViewType)
2065#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2066pub enum ImageViewType {
2067    Type1D,
2068    Type2D,
2069    Type3D,
2070    TypeCube,
2071    Type1DArray,
2072    Type2DArray,
2073    TypeCubeArray,
2074    Unknown(vks::core::VkImageViewType),
2075}
2076
2077impl From<ImageViewType> for vks::core::VkImageViewType {
2078    fn from(view_type: ImageViewType) -> Self {
2079        match view_type {
2080            ImageViewType::Type1D => vks::core::VK_IMAGE_VIEW_TYPE_1D,
2081            ImageViewType::Type2D => vks::core::VK_IMAGE_VIEW_TYPE_2D,
2082            ImageViewType::Type3D => vks::core::VK_IMAGE_VIEW_TYPE_3D,
2083            ImageViewType::TypeCube => vks::core::VK_IMAGE_VIEW_TYPE_CUBE,
2084            ImageViewType::Type1DArray => vks::core::VK_IMAGE_VIEW_TYPE_1D_ARRAY,
2085            ImageViewType::Type2DArray => vks::core::VK_IMAGE_VIEW_TYPE_2D_ARRAY,
2086            ImageViewType::TypeCubeArray => vks::core::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
2087            ImageViewType::Unknown(view_type) => view_type,
2088        }
2089    }
2090}
2091
2092/// See [`VkComponentSwizzle`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkComponentSwizzle)
2093#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2094pub enum ComponentSwizzle {
2095    Identity,
2096    Zero,
2097    One,
2098    R,
2099    G,
2100    B,
2101    A,
2102    Unknown(vks::core::VkComponentSwizzle),
2103}
2104
2105impl From<ComponentSwizzle> for vks::core::VkComponentSwizzle {
2106    fn from(swizzle: ComponentSwizzle) -> Self {
2107        match swizzle {
2108            ComponentSwizzle::Identity => vks::core::VK_COMPONENT_SWIZZLE_IDENTITY,
2109            ComponentSwizzle::Zero => vks::core::VK_COMPONENT_SWIZZLE_ZERO,
2110            ComponentSwizzle::One => vks::core::VK_COMPONENT_SWIZZLE_ONE,
2111            ComponentSwizzle::R => vks::core::VK_COMPONENT_SWIZZLE_R,
2112            ComponentSwizzle::G => vks::core::VK_COMPONENT_SWIZZLE_G,
2113            ComponentSwizzle::B => vks::core::VK_COMPONENT_SWIZZLE_B,
2114            ComponentSwizzle::A => vks::core::VK_COMPONENT_SWIZZLE_A,
2115            ComponentSwizzle::Unknown(swizzle) => swizzle,
2116        }
2117    }
2118}
2119
2120/// See [`VkVertexInputRate`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkVertexInputRate)
2121#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2122pub enum VertexInputRate {
2123    Vertex,
2124    Instance,
2125    Unknown(vks::core::VkVertexInputRate),
2126}
2127
2128impl From<VertexInputRate> for vks::core::VkVertexInputRate {
2129    fn from(rate: VertexInputRate) -> Self {
2130        match rate {
2131            VertexInputRate::Vertex => vks::core::VK_VERTEX_INPUT_RATE_VERTEX,
2132            VertexInputRate::Instance => vks::core::VK_VERTEX_INPUT_RATE_INSTANCE,
2133            VertexInputRate::Unknown(rate) => rate,
2134        }
2135    }
2136}
2137
2138/// See [`VkPrimitiveTopology`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPrimitiveTopology)
2139#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2140pub enum PrimitiveTopology {
2141    PointList,
2142    LineList,
2143    LineStrip,
2144    TriangleList,
2145    TriangleStrip,
2146    TriangleFan,
2147    LineListWithAdjacency,
2148    LineStripWithAdjacency,
2149    TriangleListWithAdjacency,
2150    TriangleStripWithAdjacency,
2151    PatchList,
2152    Unknown(vks::core::VkPrimitiveTopology)
2153}
2154
2155impl From<PrimitiveTopology> for vks::core::VkPrimitiveTopology {
2156    fn from(topology: PrimitiveTopology) -> Self {
2157        match topology {
2158            PrimitiveTopology::PointList => vks::core::VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
2159            PrimitiveTopology::LineList => vks::core::VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
2160            PrimitiveTopology::LineStrip => vks::core::VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
2161            PrimitiveTopology::TriangleList => vks::core::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
2162            PrimitiveTopology::TriangleStrip => vks::core::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
2163            PrimitiveTopology::TriangleFan => vks::core::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
2164            PrimitiveTopology::LineListWithAdjacency => vks::core::VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
2165            PrimitiveTopology::LineStripWithAdjacency => vks::core::VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
2166            PrimitiveTopology::TriangleListWithAdjacency => vks::core::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
2167            PrimitiveTopology::TriangleStripWithAdjacency => vks::core::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
2168            PrimitiveTopology::PatchList => vks::core::VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
2169            PrimitiveTopology::Unknown(topology) => topology,
2170        }
2171    }
2172}
2173
2174/// See [`VkPolygonMode`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPolygonMode)
2175#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2176pub enum PolygonMode {
2177    Fill,
2178    Line,
2179    Point,
2180    Unknown(vks::core::VkPolygonMode),
2181}
2182
2183impl From<PolygonMode> for vks::core::VkPolygonMode {
2184    fn from(mode: PolygonMode) -> Self {
2185        match mode {
2186            PolygonMode::Fill => vks::core::VK_POLYGON_MODE_FILL,
2187            PolygonMode::Line => vks::core::VK_POLYGON_MODE_LINE,
2188            PolygonMode::Point => vks::core::VK_POLYGON_MODE_POINT,
2189            PolygonMode::Unknown(mode) => mode,
2190        }
2191    }
2192}
2193
2194/// See [`VkFrontFace`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFrontFace)
2195#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2196pub enum FrontFace {
2197    CounterClockwise,
2198    Clockwise,
2199    Unknown(vks::core::VkFrontFace),
2200}
2201
2202impl From<FrontFace> for vks::core::VkFrontFace {
2203    fn from(face: FrontFace) -> Self {
2204        match face {
2205            FrontFace::CounterClockwise => vks::core::VK_FRONT_FACE_COUNTER_CLOCKWISE,
2206            FrontFace::Clockwise => vks::core::VK_FRONT_FACE_CLOCKWISE,
2207            FrontFace::Unknown(face) => face,
2208        }
2209    }
2210}
2211
2212/// See [`VkCompareOp`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCompareOp)
2213#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2214pub enum CompareOp {
2215    Never,
2216    Less,
2217    Equal,
2218    LessOrEqual,
2219    Greater,
2220    NotEqual,
2221    GreaterOrEqual,
2222    Always,
2223    Unknown(vks::core::VkCompareOp),
2224}
2225
2226impl From<CompareOp> for vks::core::VkCompareOp {
2227    fn from(op: CompareOp) -> Self {
2228        match op {
2229            CompareOp::Never => vks::core::VK_COMPARE_OP_NEVER,
2230            CompareOp::Less => vks::core::VK_COMPARE_OP_LESS,
2231            CompareOp::Equal => vks::core::VK_COMPARE_OP_EQUAL,
2232            CompareOp::LessOrEqual => vks::core::VK_COMPARE_OP_LESS_OR_EQUAL,
2233            CompareOp::Greater => vks::core::VK_COMPARE_OP_GREATER,
2234            CompareOp::NotEqual => vks::core::VK_COMPARE_OP_NOT_EQUAL,
2235            CompareOp::GreaterOrEqual => vks::core::VK_COMPARE_OP_GREATER_OR_EQUAL,
2236            CompareOp::Always => vks::core::VK_COMPARE_OP_ALWAYS,
2237            CompareOp::Unknown(op) => op,
2238        }
2239    }
2240}
2241
2242/// See [`VkStencilOp`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkStencilOp)
2243#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2244pub enum StencilOp {
2245    Keep,
2246    Zero,
2247    Replace,
2248    IncrementAndClamp,
2249    DecrementAndClamp,
2250    Invert,
2251    IncrementAndWrap,
2252    DecrementAndWrap,
2253    Unknown(vks::core::VkStencilOp),
2254}
2255
2256impl From<StencilOp> for vks::core::VkStencilOp {
2257    fn from(op: StencilOp) -> Self {
2258        match op {
2259            StencilOp::Keep => vks::core::VK_STENCIL_OP_KEEP,
2260            StencilOp::Zero => vks::core::VK_STENCIL_OP_ZERO,
2261            StencilOp::Replace => vks::core::VK_STENCIL_OP_REPLACE,
2262            StencilOp::IncrementAndClamp => vks::core::VK_STENCIL_OP_INCREMENT_AND_CLAMP,
2263            StencilOp::DecrementAndClamp => vks::core::VK_STENCIL_OP_DECREMENT_AND_CLAMP,
2264            StencilOp::Invert => vks::core::VK_STENCIL_OP_INVERT,
2265            StencilOp::IncrementAndWrap => vks::core::VK_STENCIL_OP_INCREMENT_AND_WRAP,
2266            StencilOp::DecrementAndWrap => vks::core::VK_STENCIL_OP_DECREMENT_AND_WRAP,
2267            StencilOp::Unknown(op) => op,
2268        }
2269    }
2270}
2271
2272/// See [`VkLogicOp`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkLogicOp)
2273#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2274pub enum LogicOp {
2275    Clear,
2276    And,
2277    AndReverse,
2278    Copy,
2279    AndInverted,
2280    NoOp,
2281    Xor,
2282    Or,
2283    Nor,
2284    Equivalent,
2285    Invert,
2286    OrReverse,
2287    CopyInverted,
2288    OrInverted,
2289    Nand,
2290    Set,
2291    Unknown(vks::core::VkLogicOp),
2292}
2293
2294impl From<LogicOp> for vks::core::VkLogicOp {
2295    fn from(op: LogicOp) -> Self {
2296        match op {
2297            LogicOp::Clear => vks::core::VK_LOGIC_OP_CLEAR,
2298            LogicOp::And => vks::core::VK_LOGIC_OP_AND,
2299            LogicOp::AndReverse => vks::core::VK_LOGIC_OP_AND_REVERSE,
2300            LogicOp::Copy => vks::core::VK_LOGIC_OP_COPY,
2301            LogicOp::AndInverted => vks::core::VK_LOGIC_OP_AND_INVERTED,
2302            LogicOp::NoOp => vks::core::VK_LOGIC_OP_NO_OP,
2303            LogicOp::Xor => vks::core::VK_LOGIC_OP_XOR,
2304            LogicOp::Or => vks::core::VK_LOGIC_OP_OR,
2305            LogicOp::Nor => vks::core::VK_LOGIC_OP_NOR,
2306            LogicOp::Equivalent => vks::core::VK_LOGIC_OP_EQUIVALENT,
2307            LogicOp::Invert => vks::core::VK_LOGIC_OP_INVERT,
2308            LogicOp::OrReverse => vks::core::VK_LOGIC_OP_OR_REVERSE,
2309            LogicOp::CopyInverted => vks::core::VK_LOGIC_OP_COPY_INVERTED,
2310            LogicOp::OrInverted => vks::core::VK_LOGIC_OP_OR_INVERTED,
2311            LogicOp::Nand => vks::core::VK_LOGIC_OP_NAND,
2312            LogicOp::Set => vks::core::VK_LOGIC_OP_SET,
2313            LogicOp::Unknown(op) => op,
2314        }
2315    }
2316}
2317
2318/// See [`VkBlendFactor`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBlendFactor)
2319#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2320pub enum BlendFactor {
2321    Zero,
2322    One,
2323    SrcColor,
2324    OneMinusSrcColor,
2325    DstColor,
2326    OneMinusDstColor,
2327    SrcAlpha,
2328    OneMinusSrcAlpha,
2329    DstAlpha,
2330    OneMinusDstAlpha,
2331    ConstantColor,
2332    OneMinusConstantColor,
2333    ConstantAlpha,
2334    OneMinusConstantAlpha,
2335    SrcAlphaSaturate,
2336    Src1Color,
2337    OneMinusSrc1Color,
2338    Src1Alpha,
2339    OneMinusSrc1Alpha,
2340    Unknown(vks::core::VkBlendFactor),
2341}
2342
2343impl From<BlendFactor> for vks::core::VkBlendFactor {
2344    fn from(factor: BlendFactor) -> Self {
2345        match factor {
2346            BlendFactor::Zero => vks::core::VK_BLEND_FACTOR_ZERO,
2347            BlendFactor::One => vks::core::VK_BLEND_FACTOR_ONE,
2348            BlendFactor::SrcColor => vks::core::VK_BLEND_FACTOR_SRC_COLOR,
2349            BlendFactor::OneMinusSrcColor => vks::core::VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
2350            BlendFactor::DstColor => vks::core::VK_BLEND_FACTOR_DST_COLOR,
2351            BlendFactor::OneMinusDstColor => vks::core::VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
2352            BlendFactor::SrcAlpha => vks::core::VK_BLEND_FACTOR_SRC_ALPHA,
2353            BlendFactor::OneMinusSrcAlpha => vks::core::VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
2354            BlendFactor::DstAlpha => vks::core::VK_BLEND_FACTOR_DST_ALPHA,
2355            BlendFactor::OneMinusDstAlpha => vks::core::VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
2356            BlendFactor::ConstantColor => vks::core::VK_BLEND_FACTOR_CONSTANT_COLOR,
2357            BlendFactor::OneMinusConstantColor => vks::core::VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
2358            BlendFactor::ConstantAlpha => vks::core::VK_BLEND_FACTOR_CONSTANT_ALPHA,
2359            BlendFactor::OneMinusConstantAlpha => vks::core::VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
2360            BlendFactor::SrcAlphaSaturate => vks::core::VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
2361            BlendFactor::Src1Color => vks::core::VK_BLEND_FACTOR_SRC1_COLOR,
2362            BlendFactor::OneMinusSrc1Color => vks::core::VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
2363            BlendFactor::Src1Alpha => vks::core::VK_BLEND_FACTOR_SRC1_ALPHA,
2364            BlendFactor::OneMinusSrc1Alpha => vks::core::VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
2365            BlendFactor::Unknown(factor) => factor,
2366        }
2367    }
2368}
2369
2370/// See [`VkBlendOp`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBlendOp)
2371#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2372pub enum BlendOp {
2373    Add,
2374    Subtract,
2375    ReverseSubtract,
2376    Min,
2377    Max,
2378    Unknown(vks::core::VkBlendOp),
2379}
2380
2381impl From<BlendOp> for vks::core::VkBlendOp {
2382    fn from(op: BlendOp) -> Self {
2383        match op {
2384            BlendOp::Add => vks::core::VK_BLEND_OP_ADD,
2385            BlendOp::Subtract => vks::core::VK_BLEND_OP_SUBTRACT,
2386            BlendOp::ReverseSubtract => vks::core::VK_BLEND_OP_REVERSE_SUBTRACT,
2387            BlendOp::Min => vks::core::VK_BLEND_OP_MIN,
2388            BlendOp::Max => vks::core::VK_BLEND_OP_MAX,
2389            BlendOp::Unknown(op) => op,
2390        }
2391    }
2392}
2393
2394/// See [`VkDynamicState`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDynamicState)
2395#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2396pub enum DynamicState {
2397    Viewport,
2398    Scissor,
2399    LineWidth,
2400    DepthBias,
2401    BlendConstants,
2402    DepthBounds,
2403    StencilCompareMask,
2404    StencilWriteMask,
2405    StencilReference,
2406    Unknown(vks::core::VkDynamicState),
2407}
2408
2409impl From<DynamicState> for vks::core::VkDynamicState {
2410    fn from(state: DynamicState) -> Self {
2411        match state {
2412            DynamicState::Viewport => vks::core::VK_DYNAMIC_STATE_VIEWPORT,
2413            DynamicState::Scissor => vks::core::VK_DYNAMIC_STATE_SCISSOR,
2414            DynamicState::LineWidth => vks::core::VK_DYNAMIC_STATE_LINE_WIDTH,
2415            DynamicState::DepthBias => vks::core::VK_DYNAMIC_STATE_DEPTH_BIAS,
2416            DynamicState::BlendConstants => vks::core::VK_DYNAMIC_STATE_BLEND_CONSTANTS,
2417            DynamicState::DepthBounds => vks::core::VK_DYNAMIC_STATE_DEPTH_BOUNDS,
2418            DynamicState::StencilCompareMask => vks::core::VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
2419            DynamicState::StencilWriteMask => vks::core::VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
2420            DynamicState::StencilReference => vks::core::VK_DYNAMIC_STATE_STENCIL_REFERENCE,
2421            DynamicState::Unknown(state) => state,
2422        }
2423    }
2424}
2425
2426/// See [`VkFilter`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFilter)
2427#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2428pub enum Filter {
2429    Nearest,
2430    Linear,
2431    CubicImg,
2432    Unknown(vks::core::VkFilter),
2433}
2434
2435impl From<Filter> for vks::core::VkFilter {
2436    fn from(filter: Filter) -> Self {
2437        match filter {
2438            Filter::Nearest => vks::core::VK_FILTER_NEAREST,
2439            Filter::Linear => vks::core::VK_FILTER_LINEAR,
2440            Filter::CubicImg => vks::core::VK_FILTER_CUBIC_IMG,
2441            Filter::Unknown(filter) => filter,
2442        }
2443    }
2444}
2445
2446/// See [`VkSamplerMipmapMode`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSamplerMipmapMode)
2447#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2448pub enum SamplerMipmapMode {
2449    Nearest,
2450    Linear,
2451    Unknown(vks::core::VkSamplerMipmapMode),
2452}
2453
2454impl From<SamplerMipmapMode> for vks::core::VkSamplerMipmapMode {
2455    fn from(mode: SamplerMipmapMode) -> Self {
2456        match mode {
2457            SamplerMipmapMode::Nearest => vks::core::VK_SAMPLER_MIPMAP_MODE_NEAREST,
2458            SamplerMipmapMode::Linear => vks::core::VK_SAMPLER_MIPMAP_MODE_LINEAR,
2459            SamplerMipmapMode::Unknown(mode) => mode,
2460        }
2461    }
2462}
2463
2464/// See [`VkSamplerAddressMode`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSamplerAddressMode)
2465#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2466pub enum SamplerAddressMode {
2467    Repeat,
2468    MirroredRepeat,
2469    ClampToEdge,
2470    ClampToBorder,
2471    MirrorClampToEdge,
2472    Unknown(vks::core::VkSamplerAddressMode),
2473}
2474
2475impl From<SamplerAddressMode> for vks::core::VkSamplerAddressMode {
2476    fn from(mode: SamplerAddressMode) -> Self {
2477        match mode {
2478            SamplerAddressMode::Repeat => vks::core::VK_SAMPLER_ADDRESS_MODE_REPEAT,
2479            SamplerAddressMode::MirroredRepeat => vks::core::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
2480            SamplerAddressMode::ClampToEdge => vks::core::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
2481            SamplerAddressMode::ClampToBorder => vks::core::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
2482            SamplerAddressMode::MirrorClampToEdge => vks::core::VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
2483            SamplerAddressMode::Unknown(mode) => mode,
2484        }
2485    }
2486}
2487
2488/// See [`VkBorderColor`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBorderColor)
2489#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2490pub enum BorderColor {
2491    FloatTransparentBlack,
2492    IntTransparentBlack,
2493    FloatOpaqueBlack,
2494    IntOpaqueBlack,
2495    FloatOpaqueWhite,
2496    IntOpaqueWhite,
2497    Unknown(vks::core::VkBorderColor),
2498}
2499
2500impl From<BorderColor> for vks::core::VkBorderColor {
2501    fn from(color: BorderColor) -> Self {
2502        match color {
2503            BorderColor::FloatTransparentBlack => vks::core::VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
2504            BorderColor::IntTransparentBlack => vks::core::VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
2505            BorderColor::FloatOpaqueBlack => vks::core::VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
2506            BorderColor::IntOpaqueBlack => vks::core::VK_BORDER_COLOR_INT_OPAQUE_BLACK,
2507            BorderColor::FloatOpaqueWhite => vks::core::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
2508            BorderColor::IntOpaqueWhite => vks::core::VK_BORDER_COLOR_INT_OPAQUE_WHITE,
2509            BorderColor::Unknown(color) => color,
2510        }
2511    }
2512}
2513
2514/// See [`VkDescriptorType`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorType)
2515#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2516pub enum DescriptorType {
2517    Sampler,
2518    CombinedImageSampler,
2519    SampledImage,
2520    StorageImage,
2521    UniformTexelBuffer,
2522    StorageTexelBuffer,
2523    UniformBuffer,
2524    StorageBuffer,
2525    UniformBufferDynamic,
2526    StorageBufferDynamic,
2527    InputAttachment,
2528    Unknown(vks::core::VkDescriptorType),
2529}
2530
2531impl From<DescriptorType> for vks::core::VkDescriptorType {
2532    fn from(descriptor_type: DescriptorType) -> Self {
2533        match descriptor_type {
2534            DescriptorType::Sampler => vks::core::VK_DESCRIPTOR_TYPE_SAMPLER,
2535            DescriptorType::CombinedImageSampler => vks::core::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
2536            DescriptorType::SampledImage => vks::core::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
2537            DescriptorType::StorageImage => vks::core::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
2538            DescriptorType::UniformTexelBuffer => vks::core::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
2539            DescriptorType::StorageTexelBuffer => vks::core::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
2540            DescriptorType::UniformBuffer => vks::core::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
2541            DescriptorType::StorageBuffer => vks::core::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
2542            DescriptorType::UniformBufferDynamic => vks::core::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
2543            DescriptorType::StorageBufferDynamic => vks::core::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
2544            DescriptorType::InputAttachment => vks::core::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2545            DescriptorType::Unknown(descriptor_type) => descriptor_type,
2546        }
2547    }
2548}
2549
2550/// See [`VkAttachmentLoadOp`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkAttachmentLoadOp)
2551#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2552pub enum AttachmentLoadOp {
2553    Load,
2554    Clear,
2555    DontCare,
2556    Unknown(vks::core::VkAttachmentLoadOp),
2557}
2558
2559impl From<AttachmentLoadOp> for vks::core::VkAttachmentLoadOp {
2560    fn from(op: AttachmentLoadOp) -> Self {
2561        match op {
2562            AttachmentLoadOp::Load => vks::core::VK_ATTACHMENT_LOAD_OP_LOAD,
2563            AttachmentLoadOp::Clear => vks::core::VK_ATTACHMENT_LOAD_OP_CLEAR,
2564            AttachmentLoadOp::DontCare => vks::core::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
2565            AttachmentLoadOp::Unknown(op) => op,
2566        }
2567    }
2568}
2569
2570impl From<vks::core::VkAttachmentLoadOp> for AttachmentLoadOp {
2571    fn from(op: vks::core::VkAttachmentLoadOp) -> Self {
2572        match op {
2573            vks::core::VK_ATTACHMENT_LOAD_OP_LOAD => AttachmentLoadOp::Load,
2574            vks::core::VK_ATTACHMENT_LOAD_OP_CLEAR => AttachmentLoadOp::Clear,
2575            vks::core::VK_ATTACHMENT_LOAD_OP_DONT_CARE => AttachmentLoadOp::DontCare,
2576            _ => AttachmentLoadOp::Unknown(op),
2577        }
2578    }
2579}
2580
2581/// See [`VkAttachmentStoreOp`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkAttachmentStoreOp)
2582#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2583pub enum AttachmentStoreOp {
2584    Store,
2585    DontCare,
2586    Unknown(vks::core::VkAttachmentStoreOp),
2587}
2588
2589impl From<AttachmentStoreOp> for vks::core::VkAttachmentStoreOp {
2590    fn from(op: AttachmentStoreOp) -> Self {
2591        match op {
2592            AttachmentStoreOp::Store => vks::core::VK_ATTACHMENT_STORE_OP_STORE,
2593            AttachmentStoreOp::DontCare => vks::core::VK_ATTACHMENT_STORE_OP_DONT_CARE,
2594            AttachmentStoreOp::Unknown(op) => op,
2595        }
2596    }
2597}
2598
2599impl From<vks::core::VkAttachmentStoreOp> for AttachmentStoreOp {
2600    fn from(op: vks::core::VkAttachmentStoreOp) -> Self {
2601        match op {
2602            vks::core::VK_ATTACHMENT_STORE_OP_STORE => AttachmentStoreOp::Store,
2603            vks::core::VK_ATTACHMENT_STORE_OP_DONT_CARE => AttachmentStoreOp::DontCare,
2604            _ => AttachmentStoreOp::Unknown(op),
2605        }
2606    }
2607}
2608
2609/// See [`VkPipelineBindPoint`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineBindPoint)
2610#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2611pub enum PipelineBindPoint {
2612    Graphics,
2613    Compute,
2614    Unknown(vks::core::VkPipelineBindPoint),
2615}
2616
2617impl From<PipelineBindPoint> for vks::core::VkPipelineBindPoint {
2618    fn from(bind_point: PipelineBindPoint) -> Self {
2619        match bind_point {
2620            PipelineBindPoint::Graphics => vks::core::VK_PIPELINE_BIND_POINT_GRAPHICS,
2621            PipelineBindPoint::Compute => vks::core::VK_PIPELINE_BIND_POINT_COMPUTE,
2622            PipelineBindPoint::Unknown(bind_point) => bind_point,
2623        }
2624    }
2625}
2626
2627impl From<vks::core::VkPipelineBindPoint> for PipelineBindPoint {
2628    fn from(bind_point: vks::core::VkPipelineBindPoint) -> Self {
2629        match bind_point {
2630            vks::core::VK_PIPELINE_BIND_POINT_GRAPHICS => PipelineBindPoint::Graphics,
2631            vks::core::VK_PIPELINE_BIND_POINT_COMPUTE => PipelineBindPoint::Compute,
2632            _ => PipelineBindPoint::Unknown(bind_point),
2633        }
2634    }
2635}
2636
2637/// See [`VkCommandBufferLevel`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandBufferLevel)
2638#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2639pub enum CommandBufferLevel {
2640    Primary,
2641    Secondary,
2642    Unknown(vks::core::VkCommandBufferLevel),
2643}
2644
2645impl From<CommandBufferLevel> for vks::core::VkCommandBufferLevel {
2646    fn from(level: CommandBufferLevel) -> Self {
2647        match level {
2648            CommandBufferLevel::Primary => vks::core::VK_COMMAND_BUFFER_LEVEL_PRIMARY,
2649            CommandBufferLevel::Secondary => vks::core::VK_COMMAND_BUFFER_LEVEL_SECONDARY,
2650            CommandBufferLevel::Unknown(level) => level,
2651        }
2652    }
2653}
2654
2655/// See [`VkIndexType`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkIndexType)
2656#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2657pub enum IndexType {
2658    UInt16,
2659    UInt32,
2660    Unknown(vks::core::VkIndexType),
2661}
2662
2663impl From<IndexType> for vks::core::VkIndexType {
2664    fn from(index_type: IndexType) -> Self {
2665        match index_type {
2666            IndexType::UInt16 => vks::core::VK_INDEX_TYPE_UINT16,
2667            IndexType::UInt32 => vks::core::VK_INDEX_TYPE_UINT32,
2668            IndexType::Unknown(index_type) => index_type,
2669        }
2670    }
2671}
2672
2673/// See [`VkSubpassContents`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSubpassContents)
2674#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2675pub enum SubpassContents {
2676    Inline,
2677    SecondaryCommandBuffers,
2678    Unknown(vks::core::VkSubpassContents),
2679}
2680
2681impl From<SubpassContents> for vks::core::VkSubpassContents {
2682    fn from(contents: SubpassContents) -> Self {
2683        match contents {
2684            SubpassContents::Inline => vks::core::VK_SUBPASS_CONTENTS_INLINE,
2685            SubpassContents::SecondaryCommandBuffers => vks::core::VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
2686            SubpassContents::Unknown(contents) => contents,
2687        }
2688    }
2689}
2690
2691gen_chain_struct! {
2692    name: ApplicationInfoChain [ApplicationInfoChainWrapper],
2693    query: ApplicationInfoChainQuery [ApplicationInfoChainQueryWrapper],
2694    vks: vks::core::VkApplicationInfo,
2695    input: true,
2696    output: false,
2697}
2698
2699/// See [`VkApplicationInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkApplicationInfo)
2700#[derive(Debug, Clone, PartialEq)]
2701pub struct ApplicationInfo {
2702    pub application_name: Option<String>,
2703    pub application_version: u32,
2704    pub engine_name: Option<String>,
2705    pub engine_version: u32,
2706    pub api_version: Option<Version>,
2707    pub chain: Option<ApplicationInfoChain>,
2708}
2709
2710#[derive(Debug)]
2711struct VkApplicationInfoWrapper {
2712    pub vks_struct: vks::core::VkApplicationInfo,
2713    application_name_cstr: Option<CString>,
2714    engine_name_cstr: Option<CString>,
2715    chain: Option<ApplicationInfoChainWrapper>,
2716}
2717
2718impl VkApplicationInfoWrapper {
2719    pub fn new(info: &ApplicationInfo, with_chain: bool) -> Self {
2720        let application_name_cstr = utils::cstr_from_string(info.application_name.clone());
2721        let engine_name_cstr = utils::cstr_from_string(info.engine_name.clone());
2722        let (pnext, chain) = ApplicationInfoChainWrapper::new_optional(&info.chain, with_chain);
2723
2724        VkApplicationInfoWrapper {
2725            vks_struct: vks::core::VkApplicationInfo {
2726                sType: vks::core::VK_STRUCTURE_TYPE_APPLICATION_INFO,
2727                pNext: pnext,
2728                pApplicationName: application_name_cstr.1,
2729                applicationVersion: info.application_version,
2730                pEngineName: engine_name_cstr.1,
2731                engineVersion: info.engine_version,
2732                apiVersion: Version::api_version_from_optional(info.api_version),
2733            },
2734            application_name_cstr: application_name_cstr.0,
2735            engine_name_cstr: engine_name_cstr.0,
2736            chain: chain,
2737        }
2738    }
2739}
2740
2741gen_chain_struct! {
2742    name: InstanceCreateInfoChain [InstanceCreateInfoChainWrapper],
2743    query: InstanceCreateInfoChainQuery [InstanceCreateInfoChainQueryWrapper],
2744    vks: vks::core::VkInstanceCreateInfo,
2745    input: true,
2746    output: false,
2747
2748    debug_report_callback_create_info_ext: ext_debug_report::DebugReportCallbackCreateInfoExt {
2749        fn_add: add_debug_report_callback_create_info_ext,
2750        fn_has: has_debug_report_callback_create_info_ext,
2751        fn_get: get_debug_report_callback_create_info_ext,
2752        wrapper: ext_debug_report::VkDebugReportCallbackCreateInfoEXTWrapper,
2753        vks: vks::ext_debug_report::VkDebugReportCallbackCreateInfoEXT,
2754        stype: vks::core::VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
2755    }
2756
2757    validation_flags_ext: ext_validation_flags::ValidationFlagsExt {
2758        fn_add: add_validation_flags_ext,
2759        fn_has: has_validation_flags_ext,
2760        fn_get: get_validation_flags_ext,
2761        wrapper: ext_validation_flags::VkValidationFlagsEXTWrapper,
2762        vks: vks::ext_validation_flags::VkValidationFlagsEXT,
2763        stype: vks::core::VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,
2764    }
2765}
2766
2767/// See [`VkInstanceCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkInstanceCreateInfo)
2768#[derive(Debug, Clone, PartialEq)]
2769pub struct InstanceCreateInfo {
2770    pub flags: InstanceCreateFlags,
2771    pub application_info: Option<ApplicationInfo>,
2772    pub enabled_layers: Vec<String>,
2773    pub enabled_extensions: InstanceExtensions,
2774    pub chain: Option<InstanceCreateInfoChain>,
2775}
2776
2777#[derive(Debug)]
2778struct VkInstanceCreateInfoWrapper {
2779    pub vks_struct: vks::core::VkInstanceCreateInfo,
2780    application_info: Option<Box<VkApplicationInfoWrapper>>,
2781    enabled_layers: Vec<CString>,
2782    enabled_layers_ptrs: Vec<*const c_char>,
2783    enabled_extensions: Vec<CString>,
2784    enabled_extensions_ptrs: Vec<*const c_char>,
2785    chain: Option<InstanceCreateInfoChainWrapper>,
2786}
2787
2788impl VkInstanceCreateInfoWrapper {
2789    pub fn new(create_info: &InstanceCreateInfo, with_chain: bool) -> Self {
2790        let (application_info_ptr, application_info) = match create_info.application_info {
2791            Some(ref application_info) => {
2792                let application_info: Box<_> = Box::new(VkApplicationInfoWrapper::new(application_info, true));
2793                (&application_info.vks_struct as *const _, Some(application_info))
2794            }
2795
2796            None => (ptr::null(), None),
2797        };
2798
2799        let enabled_layers: Vec<_> = create_info.enabled_layers.iter()
2800            .cloned()
2801            .map(CString::new)
2802            .map(Result::unwrap)
2803            .collect();
2804        let enabled_layers_ptrs: Vec<_> = enabled_layers
2805            .iter()
2806            .map(|l| l.as_ptr())
2807            .collect();
2808        let enabled_layers_ptr = if !enabled_layers_ptrs.is_empty() {
2809            enabled_layers_ptrs.as_ptr()
2810        }
2811        else {
2812            ptr::null()
2813        };
2814
2815        let enabled_extensions = create_info.enabled_extensions.to_cstring_vec();
2816        let enabled_extensions_ptrs: Vec<_> = enabled_extensions
2817            .iter()
2818            .map(|l| l.as_ptr())
2819            .collect();
2820        let enabled_extensions_ptr = if !enabled_extensions_ptrs.is_empty() {
2821            enabled_extensions_ptrs.as_ptr()
2822        }
2823        else {
2824            ptr::null()
2825        };
2826
2827        let (pnext, chain) = InstanceCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
2828
2829        VkInstanceCreateInfoWrapper {
2830            vks_struct: vks::core::VkInstanceCreateInfo {
2831                sType: vks::core::VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
2832                pNext: pnext,
2833                flags: create_info.flags.bits,
2834                pApplicationInfo: application_info_ptr,
2835                enabledLayerCount: enabled_layers_ptrs.len() as u32,
2836                ppEnabledLayerNames: enabled_layers_ptr,
2837                enabledExtensionCount: enabled_extensions_ptrs.len() as u32,
2838                ppEnabledExtensionNames: enabled_extensions_ptr,
2839            },
2840            application_info: application_info,
2841            enabled_layers: enabled_layers,
2842            enabled_layers_ptrs: enabled_layers_ptrs,
2843            enabled_extensions: enabled_extensions,
2844            enabled_extensions_ptrs: enabled_extensions_ptrs,
2845            chain: chain,
2846        }
2847    }
2848}
2849
2850/// See [`VkAllocationCallbacks`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkAllocationCallbacks)
2851pub trait Allocator: Send + Sync + fmt::Debug {
2852    fn alloc(&self, size: usize, alignment: usize, allocation_scope: SystemAllocationSope) -> *mut c_void;
2853    fn realloc(&self, original: *mut c_void, size: usize, alignment: usize, allocation_scope: SystemAllocationSope) -> *mut c_void;
2854    fn free(&self, memory: *mut c_void);
2855
2856    fn has_internal_alloc(&self) -> bool {
2857        false
2858    }
2859
2860    #[allow(unused_variables)]
2861    fn internal_alloc(&self, size: usize, allocation_type: InternalAllocationType, allocation_scope: SystemAllocationSope) {
2862        panic!("Default dummy implementation of Allocator::internal_alloc called. Make sure to either implement all three of has_internal_alloc, internal_alloc, and internal_free, or none of them.");
2863    }
2864
2865    #[allow(unused_variables)]
2866    fn internal_free(&self, size: usize, allocation_type: InternalAllocationType, allocation_scope: SystemAllocationSope) {
2867        panic!("Default dummy implementation of Allocator::internal_free called. Make sure to either implement all three of has_internal_alloc, internal_alloc, and internal_free, or none of them.");
2868    }
2869}
2870
2871/// See [`VkPhysicalDeviceFeatures`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPhysicalDeviceFeatures)
2872#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
2873pub struct PhysicalDeviceFeatures {
2874    pub robust_buffer_access: bool,
2875    pub full_draw_index_uint32: bool,
2876    pub image_cube_array: bool,
2877    pub independent_blend: bool,
2878    pub geometry_shader: bool,
2879    pub tessellation_shader: bool,
2880    pub sample_rate_shading: bool,
2881    pub dual_src_blend: bool,
2882    pub logic_op: bool,
2883    pub multi_draw_indirect: bool,
2884    pub draw_indirect_first_instance: bool,
2885    pub depth_clamp: bool,
2886    pub depth_bias_clamp: bool,
2887    pub fill_mode_non_solid: bool,
2888    pub depth_bounds: bool,
2889    pub wide_lines: bool,
2890    pub large_points: bool,
2891    pub alpha_to_one: bool,
2892    pub multi_viewport: bool,
2893    pub sampler_anisotropy: bool,
2894    pub texture_compression_etc2: bool,
2895    pub texture_compression_astc_ldr: bool,
2896    pub texture_compression_bc: bool,
2897    pub occlusion_query_precise: bool,
2898    pub pipeline_statistics_query: bool,
2899    pub vertex_pipeline_stores_and_atomics: bool,
2900    pub fragment_stores_and_atomics: bool,
2901    pub shader_tessellation_and_geometry_point_size: bool,
2902    pub shader_image_gather_extended: bool,
2903    pub shader_storage_image_extended_formats: bool,
2904    pub shader_storage_image_multisample: bool,
2905    pub shader_storage_image_read_without_format: bool,
2906    pub shader_storage_image_write_without_format: bool,
2907    pub shader_uniform_buffer_array_dynamic_indexing: bool,
2908    pub shader_sampled_image_array_dynamic_indexing: bool,
2909    pub shader_storage_buffer_array_dynamic_indexing: bool,
2910    pub shader_storage_image_array_dynamic_indexing: bool,
2911    pub shader_clip_distance: bool,
2912    pub shader_cull_distance: bool,
2913    pub shader_float64: bool,
2914    pub shader_int64: bool,
2915    pub shader_int16: bool,
2916    pub shader_resource_residency: bool,
2917    pub shader_resource_min_lod: bool,
2918    pub sparse_binding: bool,
2919    pub sparse_residency_buffer: bool,
2920    pub sparse_residency_image_2d: bool,
2921    pub sparse_residency_image_3d: bool,
2922    pub sparse_residency_2_samples: bool,
2923    pub sparse_residency_4_samples: bool,
2924    pub sparse_residency_8_samples: bool,
2925    pub sparse_residency_16_samples: bool,
2926    pub sparse_residency_aliased: bool,
2927    pub variable_multisample_rate: bool,
2928    pub inherited_queries: bool,
2929}
2930
2931impl<'a> From<&'a vks::core::VkPhysicalDeviceFeatures> for PhysicalDeviceFeatures {
2932    fn from(featurs: &'a vks::core::VkPhysicalDeviceFeatures) -> Self {
2933        PhysicalDeviceFeatures {
2934            robust_buffer_access: utils::from_vk_bool(featurs.robustBufferAccess),
2935            full_draw_index_uint32: utils::from_vk_bool(featurs.fullDrawIndexUint32),
2936            image_cube_array: utils::from_vk_bool(featurs.imageCubeArray),
2937            independent_blend: utils::from_vk_bool(featurs.independentBlend),
2938            geometry_shader: utils::from_vk_bool(featurs.geometryShader),
2939            tessellation_shader: utils::from_vk_bool(featurs.tessellationShader),
2940            sample_rate_shading: utils::from_vk_bool(featurs.sampleRateShading),
2941            dual_src_blend: utils::from_vk_bool(featurs.dualSrcBlend),
2942            logic_op: utils::from_vk_bool(featurs.logicOp),
2943            multi_draw_indirect: utils::from_vk_bool(featurs.multiDrawIndirect),
2944            draw_indirect_first_instance: utils::from_vk_bool(featurs.drawIndirectFirstInstance),
2945            depth_clamp: utils::from_vk_bool(featurs.depthClamp),
2946            depth_bias_clamp: utils::from_vk_bool(featurs.depthBiasClamp),
2947            fill_mode_non_solid: utils::from_vk_bool(featurs.fillModeNonSolid),
2948            depth_bounds: utils::from_vk_bool(featurs.depthBounds),
2949            wide_lines: utils::from_vk_bool(featurs.wideLines),
2950            large_points: utils::from_vk_bool(featurs.largePoints),
2951            alpha_to_one: utils::from_vk_bool(featurs.alphaToOne),
2952            multi_viewport: utils::from_vk_bool(featurs.multiViewport),
2953            sampler_anisotropy: utils::from_vk_bool(featurs.samplerAnisotropy),
2954            texture_compression_etc2: utils::from_vk_bool(featurs.textureCompressionETC2),
2955            texture_compression_astc_ldr: utils::from_vk_bool(featurs.textureCompressionASTC_LDR),
2956            texture_compression_bc: utils::from_vk_bool(featurs.textureCompressionBC),
2957            occlusion_query_precise: utils::from_vk_bool(featurs.occlusionQueryPrecise),
2958            pipeline_statistics_query: utils::from_vk_bool(featurs.pipelineStatisticsQuery),
2959            vertex_pipeline_stores_and_atomics: utils::from_vk_bool(featurs.vertexPipelineStoresAndAtomics),
2960            fragment_stores_and_atomics: utils::from_vk_bool(featurs.fragmentStoresAndAtomics),
2961            shader_tessellation_and_geometry_point_size: utils::from_vk_bool(featurs.shaderTessellationAndGeometryPointSize),
2962            shader_image_gather_extended: utils::from_vk_bool(featurs.shaderImageGatherExtended),
2963            shader_storage_image_extended_formats: utils::from_vk_bool(featurs.shaderStorageImageExtendedFormats),
2964            shader_storage_image_multisample: utils::from_vk_bool(featurs.shaderStorageImageMultisample),
2965            shader_storage_image_read_without_format: utils::from_vk_bool(featurs.shaderStorageImageReadWithoutFormat),
2966            shader_storage_image_write_without_format: utils::from_vk_bool(featurs.shaderStorageImageWriteWithoutFormat),
2967            shader_uniform_buffer_array_dynamic_indexing: utils::from_vk_bool(featurs.shaderUniformBufferArrayDynamicIndexing),
2968            shader_sampled_image_array_dynamic_indexing: utils::from_vk_bool(featurs.shaderSampledImageArrayDynamicIndexing),
2969            shader_storage_buffer_array_dynamic_indexing: utils::from_vk_bool(featurs.shaderStorageBufferArrayDynamicIndexing),
2970            shader_storage_image_array_dynamic_indexing: utils::from_vk_bool(featurs.shaderStorageImageArrayDynamicIndexing),
2971            shader_clip_distance: utils::from_vk_bool(featurs.shaderClipDistance),
2972            shader_cull_distance: utils::from_vk_bool(featurs.shaderCullDistance),
2973            shader_float64: utils::from_vk_bool(featurs.shaderFloat64),
2974            shader_int64: utils::from_vk_bool(featurs.shaderInt64),
2975            shader_int16: utils::from_vk_bool(featurs.shaderInt16),
2976            shader_resource_residency: utils::from_vk_bool(featurs.shaderResourceResidency),
2977            shader_resource_min_lod: utils::from_vk_bool(featurs.shaderResourceMinLod),
2978            sparse_binding: utils::from_vk_bool(featurs.sparseBinding),
2979            sparse_residency_buffer: utils::from_vk_bool(featurs.sparseResidencyBuffer),
2980            sparse_residency_image_2d: utils::from_vk_bool(featurs.sparseResidencyImage2D),
2981            sparse_residency_image_3d: utils::from_vk_bool(featurs.sparseResidencyImage3D),
2982            sparse_residency_2_samples: utils::from_vk_bool(featurs.sparseResidency2Samples),
2983            sparse_residency_4_samples: utils::from_vk_bool(featurs.sparseResidency4Samples),
2984            sparse_residency_8_samples: utils::from_vk_bool(featurs.sparseResidency8Samples),
2985            sparse_residency_16_samples: utils::from_vk_bool(featurs.sparseResidency16Samples),
2986            sparse_residency_aliased: utils::from_vk_bool(featurs.sparseResidencyAliased),
2987            variable_multisample_rate: utils::from_vk_bool(featurs.variableMultisampleRate),
2988            inherited_queries: utils::from_vk_bool(featurs.inheritedQueries),
2989        }
2990    }
2991}
2992
2993impl<'a> From<&'a PhysicalDeviceFeatures> for vks::core::VkPhysicalDeviceFeatures {
2994    fn from(featurs: &'a PhysicalDeviceFeatures) -> Self {
2995        vks::core::VkPhysicalDeviceFeatures {
2996            robustBufferAccess: utils::to_vk_bool(featurs.robust_buffer_access),
2997            fullDrawIndexUint32: utils::to_vk_bool(featurs.full_draw_index_uint32),
2998            imageCubeArray: utils::to_vk_bool(featurs.image_cube_array),
2999            independentBlend: utils::to_vk_bool(featurs.independent_blend),
3000            geometryShader: utils::to_vk_bool(featurs.geometry_shader),
3001            tessellationShader: utils::to_vk_bool(featurs.tessellation_shader),
3002            sampleRateShading: utils::to_vk_bool(featurs.sample_rate_shading),
3003            dualSrcBlend: utils::to_vk_bool(featurs.dual_src_blend),
3004            logicOp: utils::to_vk_bool(featurs.logic_op),
3005            multiDrawIndirect: utils::to_vk_bool(featurs.multi_draw_indirect),
3006            drawIndirectFirstInstance: utils::to_vk_bool(featurs.draw_indirect_first_instance),
3007            depthClamp: utils::to_vk_bool(featurs.depth_clamp),
3008            depthBiasClamp: utils::to_vk_bool(featurs.depth_bias_clamp),
3009            fillModeNonSolid: utils::to_vk_bool(featurs.fill_mode_non_solid),
3010            depthBounds: utils::to_vk_bool(featurs.depth_bounds),
3011            wideLines: utils::to_vk_bool(featurs.wide_lines),
3012            largePoints: utils::to_vk_bool(featurs.large_points),
3013            alphaToOne: utils::to_vk_bool(featurs.alpha_to_one),
3014            multiViewport: utils::to_vk_bool(featurs.multi_viewport),
3015            samplerAnisotropy: utils::to_vk_bool(featurs.sampler_anisotropy),
3016            textureCompressionETC2: utils::to_vk_bool(featurs.texture_compression_etc2),
3017            textureCompressionASTC_LDR: utils::to_vk_bool(featurs.texture_compression_astc_ldr),
3018            textureCompressionBC: utils::to_vk_bool(featurs.texture_compression_bc),
3019            occlusionQueryPrecise: utils::to_vk_bool(featurs.occlusion_query_precise),
3020            pipelineStatisticsQuery: utils::to_vk_bool(featurs.pipeline_statistics_query),
3021            vertexPipelineStoresAndAtomics: utils::to_vk_bool(featurs.vertex_pipeline_stores_and_atomics),
3022            fragmentStoresAndAtomics: utils::to_vk_bool(featurs.fragment_stores_and_atomics),
3023            shaderTessellationAndGeometryPointSize: utils::to_vk_bool(featurs.shader_tessellation_and_geometry_point_size),
3024            shaderImageGatherExtended: utils::to_vk_bool(featurs.shader_image_gather_extended),
3025            shaderStorageImageExtendedFormats: utils::to_vk_bool(featurs.shader_storage_image_extended_formats),
3026            shaderStorageImageMultisample: utils::to_vk_bool(featurs.shader_storage_image_multisample),
3027            shaderStorageImageReadWithoutFormat: utils::to_vk_bool(featurs.shader_storage_image_read_without_format),
3028            shaderStorageImageWriteWithoutFormat: utils::to_vk_bool(featurs.shader_storage_image_write_without_format),
3029            shaderUniformBufferArrayDynamicIndexing: utils::to_vk_bool(featurs.shader_uniform_buffer_array_dynamic_indexing),
3030            shaderSampledImageArrayDynamicIndexing: utils::to_vk_bool(featurs.shader_sampled_image_array_dynamic_indexing),
3031            shaderStorageBufferArrayDynamicIndexing: utils::to_vk_bool(featurs.shader_storage_buffer_array_dynamic_indexing),
3032            shaderStorageImageArrayDynamicIndexing: utils::to_vk_bool(featurs.shader_storage_image_array_dynamic_indexing),
3033            shaderClipDistance: utils::to_vk_bool(featurs.shader_clip_distance),
3034            shaderCullDistance: utils::to_vk_bool(featurs.shader_cull_distance),
3035            shaderFloat64: utils::to_vk_bool(featurs.shader_float64),
3036            shaderInt64: utils::to_vk_bool(featurs.shader_int64),
3037            shaderInt16: utils::to_vk_bool(featurs.shader_int16),
3038            shaderResourceResidency: utils::to_vk_bool(featurs.shader_resource_residency),
3039            shaderResourceMinLod: utils::to_vk_bool(featurs.shader_resource_min_lod),
3040            sparseBinding: utils::to_vk_bool(featurs.sparse_binding),
3041            sparseResidencyBuffer: utils::to_vk_bool(featurs.sparse_residency_buffer),
3042            sparseResidencyImage2D: utils::to_vk_bool(featurs.sparse_residency_image_2d),
3043            sparseResidencyImage3D: utils::to_vk_bool(featurs.sparse_residency_image_3d),
3044            sparseResidency2Samples: utils::to_vk_bool(featurs.sparse_residency_2_samples),
3045            sparseResidency4Samples: utils::to_vk_bool(featurs.sparse_residency_4_samples),
3046            sparseResidency8Samples: utils::to_vk_bool(featurs.sparse_residency_8_samples),
3047            sparseResidency16Samples: utils::to_vk_bool(featurs.sparse_residency_16_samples),
3048            sparseResidencyAliased: utils::to_vk_bool(featurs.sparse_residency_aliased),
3049            variableMultisampleRate: utils::to_vk_bool(featurs.variable_multisample_rate),
3050            inheritedQueries: utils::to_vk_bool(featurs.inherited_queries),
3051        }
3052    }
3053}
3054
3055impl PhysicalDeviceFeatures {
3056    /// Creates a new `PhysicalDeviceFeatures` with all features set to `false`.
3057    #[inline]
3058    pub fn new() -> Self {
3059        Default::default()
3060    }
3061
3062    /// Creates a new `PhysicalDeviceFeatures` with all features set to `true`.
3063    pub fn all() -> Self {
3064        PhysicalDeviceFeatures {
3065            robust_buffer_access: true,
3066            full_draw_index_uint32: true,
3067            image_cube_array: true,
3068            independent_blend: true,
3069            geometry_shader: true,
3070            tessellation_shader: true,
3071            sample_rate_shading: true,
3072            dual_src_blend: true,
3073            logic_op: true,
3074            multi_draw_indirect: true,
3075            draw_indirect_first_instance: true,
3076            depth_clamp: true,
3077            depth_bias_clamp: true,
3078            fill_mode_non_solid: true,
3079            depth_bounds: true,
3080            wide_lines: true,
3081            large_points: true,
3082            alpha_to_one: true,
3083            multi_viewport: true,
3084            sampler_anisotropy: true,
3085            texture_compression_etc2: true,
3086            texture_compression_astc_ldr: true,
3087            texture_compression_bc: true,
3088            occlusion_query_precise: true,
3089            pipeline_statistics_query: true,
3090            vertex_pipeline_stores_and_atomics: true,
3091            fragment_stores_and_atomics: true,
3092            shader_tessellation_and_geometry_point_size: true,
3093            shader_image_gather_extended: true,
3094            shader_storage_image_extended_formats: true,
3095            shader_storage_image_multisample: true,
3096            shader_storage_image_read_without_format: true,
3097            shader_storage_image_write_without_format: true,
3098            shader_uniform_buffer_array_dynamic_indexing: true,
3099            shader_sampled_image_array_dynamic_indexing: true,
3100            shader_storage_buffer_array_dynamic_indexing: true,
3101            shader_storage_image_array_dynamic_indexing: true,
3102            shader_clip_distance: true,
3103            shader_cull_distance: true,
3104            shader_float64: true,
3105            shader_int64: true,
3106            shader_int16: true,
3107            shader_resource_residency: true,
3108            shader_resource_min_lod: true,
3109            sparse_binding: true,
3110            sparse_residency_buffer: true,
3111            sparse_residency_image_2d: true,
3112            sparse_residency_image_3d: true,
3113            sparse_residency_2_samples: true,
3114            sparse_residency_4_samples: true,
3115            sparse_residency_8_samples: true,
3116            sparse_residency_16_samples: true,
3117            sparse_residency_aliased: true,
3118            variable_multisample_rate: true,
3119            inherited_queries: true,
3120        }
3121    }
3122
3123    /// Creates a new `PhysicalDeviceFeatures` with all features set to `false`.
3124    #[inline]
3125    pub fn empty() -> Self {
3126        Default::default()
3127    }
3128
3129    /// Tests if all features are set to `false`.
3130    pub fn is_empty(&self) -> bool {
3131        !self.robust_buffer_access &&
3132        !self.full_draw_index_uint32 &&
3133        !self.image_cube_array &&
3134        !self.independent_blend &&
3135        !self.geometry_shader &&
3136        !self.tessellation_shader &&
3137        !self.sample_rate_shading &&
3138        !self.dual_src_blend &&
3139        !self.logic_op &&
3140        !self.multi_draw_indirect &&
3141        !self.draw_indirect_first_instance &&
3142        !self.depth_clamp &&
3143        !self.depth_bias_clamp &&
3144        !self.fill_mode_non_solid &&
3145        !self.depth_bounds &&
3146        !self.wide_lines &&
3147        !self.large_points &&
3148        !self.alpha_to_one &&
3149        !self.multi_viewport &&
3150        !self.sampler_anisotropy &&
3151        !self.texture_compression_etc2 &&
3152        !self.texture_compression_astc_ldr &&
3153        !self.texture_compression_bc &&
3154        !self.occlusion_query_precise &&
3155        !self.pipeline_statistics_query &&
3156        !self.vertex_pipeline_stores_and_atomics &&
3157        !self.fragment_stores_and_atomics &&
3158        !self.shader_tessellation_and_geometry_point_size &&
3159        !self.shader_image_gather_extended &&
3160        !self.shader_storage_image_extended_formats &&
3161        !self.shader_storage_image_multisample &&
3162        !self.shader_storage_image_read_without_format &&
3163        !self.shader_storage_image_write_without_format &&
3164        !self.shader_uniform_buffer_array_dynamic_indexing &&
3165        !self.shader_sampled_image_array_dynamic_indexing &&
3166        !self.shader_storage_buffer_array_dynamic_indexing &&
3167        !self.shader_storage_image_array_dynamic_indexing &&
3168        !self.shader_clip_distance &&
3169        !self.shader_cull_distance &&
3170        !self.shader_float64 &&
3171        !self.shader_int64 &&
3172        !self.shader_int16 &&
3173        !self.shader_resource_residency &&
3174        !self.shader_resource_min_lod &&
3175        !self.sparse_binding &&
3176        !self.sparse_residency_buffer &&
3177        !self.sparse_residency_image_2d &&
3178        !self.sparse_residency_image_3d &&
3179        !self.sparse_residency_2_samples &&
3180        !self.sparse_residency_4_samples &&
3181        !self.sparse_residency_8_samples &&
3182        !self.sparse_residency_16_samples &&
3183        !self.sparse_residency_aliased &&
3184        !self.variable_multisample_rate &&
3185        !self.inherited_queries
3186    }
3187
3188    /// Computes the set difference, i.e. the features that are in `self` but not in `other`.
3189    pub fn difference(&mut self, other: &Self) {
3190        self.robust_buffer_access &= !other.robust_buffer_access;
3191        self.full_draw_index_uint32 &= !other.full_draw_index_uint32;
3192        self.image_cube_array &= !other.image_cube_array;
3193        self.independent_blend &= !other.independent_blend;
3194        self.geometry_shader &= !other.geometry_shader;
3195        self.tessellation_shader &= !other.tessellation_shader;
3196        self.sample_rate_shading &= !other.sample_rate_shading;
3197        self.dual_src_blend &= !other.dual_src_blend;
3198        self.logic_op &= !other.logic_op;
3199        self.multi_draw_indirect &= !other.multi_draw_indirect;
3200        self.draw_indirect_first_instance &= !other.draw_indirect_first_instance;
3201        self.depth_clamp &= !other.depth_clamp;
3202        self.depth_bias_clamp &= !other.depth_bias_clamp;
3203        self.fill_mode_non_solid &= !other.fill_mode_non_solid;
3204        self.depth_bounds &= !other.depth_bounds;
3205        self.wide_lines &= !other.wide_lines;
3206        self.large_points &= !other.large_points;
3207        self.alpha_to_one &= !other.alpha_to_one;
3208        self.multi_viewport &= !other.multi_viewport;
3209        self.sampler_anisotropy &= !other.sampler_anisotropy;
3210        self.texture_compression_etc2 &= !other.texture_compression_etc2;
3211        self.texture_compression_astc_ldr &= !other.texture_compression_astc_ldr;
3212        self.texture_compression_bc &= !other.texture_compression_bc;
3213        self.occlusion_query_precise &= !other.occlusion_query_precise;
3214        self.pipeline_statistics_query &= !other.pipeline_statistics_query;
3215        self.vertex_pipeline_stores_and_atomics &= !other.vertex_pipeline_stores_and_atomics;
3216        self.fragment_stores_and_atomics &= !other.fragment_stores_and_atomics;
3217        self.shader_tessellation_and_geometry_point_size &= !other.shader_tessellation_and_geometry_point_size;
3218        self.shader_image_gather_extended &= !other.shader_image_gather_extended;
3219        self.shader_storage_image_extended_formats &= !other.shader_storage_image_extended_formats;
3220        self.shader_storage_image_multisample &= !other.shader_storage_image_multisample;
3221        self.shader_storage_image_read_without_format &= !other.shader_storage_image_read_without_format;
3222        self.shader_storage_image_write_without_format &= !other.shader_storage_image_write_without_format;
3223        self.shader_uniform_buffer_array_dynamic_indexing &= !other.shader_uniform_buffer_array_dynamic_indexing;
3224        self.shader_sampled_image_array_dynamic_indexing &= !other.shader_sampled_image_array_dynamic_indexing;
3225        self.shader_storage_buffer_array_dynamic_indexing &= !other.shader_storage_buffer_array_dynamic_indexing;
3226        self.shader_storage_image_array_dynamic_indexing &= !other.shader_storage_image_array_dynamic_indexing;
3227        self.shader_clip_distance &= !other.shader_clip_distance;
3228        self.shader_cull_distance &= !other.shader_cull_distance;
3229        self.shader_float64 &= !other.shader_float64;
3230        self.shader_int64 &= !other.shader_int64;
3231        self.shader_int16 &= !other.shader_int16;
3232        self.shader_resource_residency &= !other.shader_resource_residency;
3233        self.shader_resource_min_lod &= !other.shader_resource_min_lod;
3234        self.sparse_binding &= !other.sparse_binding;
3235        self.sparse_residency_buffer &= !other.sparse_residency_buffer;
3236        self.sparse_residency_image_2d &= !other.sparse_residency_image_2d;
3237        self.sparse_residency_image_3d &= !other.sparse_residency_image_3d;
3238        self.sparse_residency_2_samples &= !other.sparse_residency_2_samples;
3239        self.sparse_residency_4_samples &= !other.sparse_residency_4_samples;
3240        self.sparse_residency_8_samples &= !other.sparse_residency_8_samples;
3241        self.sparse_residency_16_samples &= !other.sparse_residency_16_samples;
3242        self.sparse_residency_aliased &= !other.sparse_residency_aliased;
3243        self.variable_multisample_rate &= !other.variable_multisample_rate;
3244        self.inherited_queries &= !other.inherited_queries;
3245    }
3246
3247    /// Computes the set intersection, i.e. the features that are in `self` and in `other`.
3248    pub fn intersection(&mut self, other: &Self) {
3249        self.robust_buffer_access &= other.robust_buffer_access;
3250        self.full_draw_index_uint32 &= other.full_draw_index_uint32;
3251        self.image_cube_array &= other.image_cube_array;
3252        self.independent_blend &= other.independent_blend;
3253        self.geometry_shader &= other.geometry_shader;
3254        self.tessellation_shader &= other.tessellation_shader;
3255        self.sample_rate_shading &= other.sample_rate_shading;
3256        self.dual_src_blend &= other.dual_src_blend;
3257        self.logic_op &= other.logic_op;
3258        self.multi_draw_indirect &= other.multi_draw_indirect;
3259        self.draw_indirect_first_instance &= other.draw_indirect_first_instance;
3260        self.depth_clamp &= other.depth_clamp;
3261        self.depth_bias_clamp &= other.depth_bias_clamp;
3262        self.fill_mode_non_solid &= other.fill_mode_non_solid;
3263        self.depth_bounds &= other.depth_bounds;
3264        self.wide_lines &= other.wide_lines;
3265        self.large_points &= other.large_points;
3266        self.alpha_to_one &= other.alpha_to_one;
3267        self.multi_viewport &= other.multi_viewport;
3268        self.sampler_anisotropy &= other.sampler_anisotropy;
3269        self.texture_compression_etc2 &= other.texture_compression_etc2;
3270        self.texture_compression_astc_ldr &= other.texture_compression_astc_ldr;
3271        self.texture_compression_bc &= other.texture_compression_bc;
3272        self.occlusion_query_precise &= other.occlusion_query_precise;
3273        self.pipeline_statistics_query &= other.pipeline_statistics_query;
3274        self.vertex_pipeline_stores_and_atomics &= other.vertex_pipeline_stores_and_atomics;
3275        self.fragment_stores_and_atomics &= other.fragment_stores_and_atomics;
3276        self.shader_tessellation_and_geometry_point_size &= other.shader_tessellation_and_geometry_point_size;
3277        self.shader_image_gather_extended &= other.shader_image_gather_extended;
3278        self.shader_storage_image_extended_formats &= other.shader_storage_image_extended_formats;
3279        self.shader_storage_image_multisample &= other.shader_storage_image_multisample;
3280        self.shader_storage_image_read_without_format &= other.shader_storage_image_read_without_format;
3281        self.shader_storage_image_write_without_format &= other.shader_storage_image_write_without_format;
3282        self.shader_uniform_buffer_array_dynamic_indexing &= other.shader_uniform_buffer_array_dynamic_indexing;
3283        self.shader_sampled_image_array_dynamic_indexing &= other.shader_sampled_image_array_dynamic_indexing;
3284        self.shader_storage_buffer_array_dynamic_indexing &= other.shader_storage_buffer_array_dynamic_indexing;
3285        self.shader_storage_image_array_dynamic_indexing &= other.shader_storage_image_array_dynamic_indexing;
3286        self.shader_clip_distance &= other.shader_clip_distance;
3287        self.shader_cull_distance &= other.shader_cull_distance;
3288        self.shader_float64 &= other.shader_float64;
3289        self.shader_int64 &= other.shader_int64;
3290        self.shader_int16 &= other.shader_int16;
3291        self.shader_resource_residency &= other.shader_resource_residency;
3292        self.shader_resource_min_lod &= other.shader_resource_min_lod;
3293        self.sparse_binding &= other.sparse_binding;
3294        self.sparse_residency_buffer &= other.sparse_residency_buffer;
3295        self.sparse_residency_image_2d &= other.sparse_residency_image_2d;
3296        self.sparse_residency_image_3d &= other.sparse_residency_image_3d;
3297        self.sparse_residency_2_samples &= other.sparse_residency_2_samples;
3298        self.sparse_residency_4_samples &= other.sparse_residency_4_samples;
3299        self.sparse_residency_8_samples &= other.sparse_residency_8_samples;
3300        self.sparse_residency_16_samples &= other.sparse_residency_16_samples;
3301        self.sparse_residency_aliased &= other.sparse_residency_aliased;
3302        self.variable_multisample_rate &= other.variable_multisample_rate;
3303        self.inherited_queries &= other.inherited_queries;
3304    }
3305
3306    /// Computes the set union, i.e. the features that are in `self` or in `other`.
3307    pub fn union(&mut self, other: &Self) {
3308        self.robust_buffer_access |= other.robust_buffer_access;
3309        self.full_draw_index_uint32 |= other.full_draw_index_uint32;
3310        self.image_cube_array |= other.image_cube_array;
3311        self.independent_blend |= other.independent_blend;
3312        self.geometry_shader |= other.geometry_shader;
3313        self.tessellation_shader |= other.tessellation_shader;
3314        self.sample_rate_shading |= other.sample_rate_shading;
3315        self.dual_src_blend |= other.dual_src_blend;
3316        self.logic_op |= other.logic_op;
3317        self.multi_draw_indirect |= other.multi_draw_indirect;
3318        self.draw_indirect_first_instance |= other.draw_indirect_first_instance;
3319        self.depth_clamp |= other.depth_clamp;
3320        self.depth_bias_clamp |= other.depth_bias_clamp;
3321        self.fill_mode_non_solid |= other.fill_mode_non_solid;
3322        self.depth_bounds |= other.depth_bounds;
3323        self.wide_lines |= other.wide_lines;
3324        self.large_points |= other.large_points;
3325        self.alpha_to_one |= other.alpha_to_one;
3326        self.multi_viewport |= other.multi_viewport;
3327        self.sampler_anisotropy |= other.sampler_anisotropy;
3328        self.texture_compression_etc2 |= other.texture_compression_etc2;
3329        self.texture_compression_astc_ldr |= other.texture_compression_astc_ldr;
3330        self.texture_compression_bc |= other.texture_compression_bc;
3331        self.occlusion_query_precise |= other.occlusion_query_precise;
3332        self.pipeline_statistics_query |= other.pipeline_statistics_query;
3333        self.vertex_pipeline_stores_and_atomics |= other.vertex_pipeline_stores_and_atomics;
3334        self.fragment_stores_and_atomics |= other.fragment_stores_and_atomics;
3335        self.shader_tessellation_and_geometry_point_size |= other.shader_tessellation_and_geometry_point_size;
3336        self.shader_image_gather_extended |= other.shader_image_gather_extended;
3337        self.shader_storage_image_extended_formats |= other.shader_storage_image_extended_formats;
3338        self.shader_storage_image_multisample |= other.shader_storage_image_multisample;
3339        self.shader_storage_image_read_without_format |= other.shader_storage_image_read_without_format;
3340        self.shader_storage_image_write_without_format |= other.shader_storage_image_write_without_format;
3341        self.shader_uniform_buffer_array_dynamic_indexing |= other.shader_uniform_buffer_array_dynamic_indexing;
3342        self.shader_sampled_image_array_dynamic_indexing |= other.shader_sampled_image_array_dynamic_indexing;
3343        self.shader_storage_buffer_array_dynamic_indexing |= other.shader_storage_buffer_array_dynamic_indexing;
3344        self.shader_storage_image_array_dynamic_indexing |= other.shader_storage_image_array_dynamic_indexing;
3345        self.shader_clip_distance |= other.shader_clip_distance;
3346        self.shader_cull_distance |= other.shader_cull_distance;
3347        self.shader_float64 |= other.shader_float64;
3348        self.shader_int64 |= other.shader_int64;
3349        self.shader_int16 |= other.shader_int16;
3350        self.shader_resource_residency |= other.shader_resource_residency;
3351        self.shader_resource_min_lod |= other.shader_resource_min_lod;
3352        self.sparse_binding |= other.sparse_binding;
3353        self.sparse_residency_buffer |= other.sparse_residency_buffer;
3354        self.sparse_residency_image_2d |= other.sparse_residency_image_2d;
3355        self.sparse_residency_image_3d |= other.sparse_residency_image_3d;
3356        self.sparse_residency_2_samples |= other.sparse_residency_2_samples;
3357        self.sparse_residency_4_samples |= other.sparse_residency_4_samples;
3358        self.sparse_residency_8_samples |= other.sparse_residency_8_samples;
3359        self.sparse_residency_16_samples |= other.sparse_residency_16_samples;
3360        self.sparse_residency_aliased |= other.sparse_residency_aliased;
3361        self.variable_multisample_rate |= other.variable_multisample_rate;
3362        self.inherited_queries |= other.inherited_queries;
3363    }
3364}
3365
3366/// See [`VkFormatProperties`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFormatProperties)
3367#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3368pub struct FormatProperties {
3369    pub linear_tiling_features: FormatFeatureFlags,
3370    pub optimal_tiling_features: FormatFeatureFlags,
3371    pub buffer_features: FormatFeatureFlags,
3372}
3373
3374impl<'a> From<&'a vks::core::VkFormatProperties> for FormatProperties {
3375    fn from(properties: &'a vks::core::VkFormatProperties) -> Self {
3376        FormatProperties {
3377            linear_tiling_features: FormatFeatureFlags::from_bits_truncate(properties.linearTilingFeatures),
3378            optimal_tiling_features: FormatFeatureFlags::from_bits_truncate(properties.optimalTilingFeatures),
3379            buffer_features: FormatFeatureFlags::from_bits_truncate(properties.bufferFeatures),
3380        }
3381    }
3382}
3383
3384impl<'a> From<&'a FormatProperties> for vks::core::VkFormatProperties {
3385    fn from(properties: &'a FormatProperties) -> Self {
3386        vks::core::VkFormatProperties {
3387            linearTilingFeatures: properties.linear_tiling_features.bits(),
3388            optimalTilingFeatures: properties.optimal_tiling_features.bits(),
3389            bufferFeatures: properties.buffer_features.bits(),
3390        }
3391    }
3392}
3393
3394/// See [`VkExtent3D`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkExtent3D)
3395#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3396pub struct Extent3D {
3397    pub width: u32,
3398    pub height: u32,
3399    pub depth: u32,
3400}
3401
3402impl<'a> From<&'a vks::core::VkExtent3D> for Extent3D {
3403    fn from(extent: &'a vks::core::VkExtent3D) -> Self {
3404        Extent3D {
3405            width: extent.width,
3406            height: extent.height,
3407            depth: extent.depth,
3408        }
3409    }
3410}
3411
3412impl<'a> From<&'a Extent3D> for vks::core::VkExtent3D {
3413    fn from(extent: &'a Extent3D) -> Self {
3414        vks::core::VkExtent3D {
3415            width: extent.width,
3416            height: extent.height,
3417            depth: extent.depth,
3418        }
3419    }
3420}
3421
3422impl Extent3D {
3423    /// Creates a new `Extent3D`.
3424    #[inline]
3425    pub fn new(width: u32, height: u32, depth: u32) -> Self {
3426        Extent3D {
3427            width: width,
3428            height: height,
3429            depth: depth,
3430        }
3431    }
3432
3433    /// Creates an `Extent3D` with all components set to 0.
3434    #[inline]
3435    pub fn zero() -> Self {
3436        Extent3D {
3437            width: 0,
3438            height: 0,
3439            depth: 0,
3440        }
3441    }
3442
3443    /// Creates an `Extent3D` from an `Extent2D` and the specified `depth` component.
3444    #[inline]
3445    pub fn from_2d(extent: &Extent2D, depth: u32) -> Self {
3446        Extent3D {
3447            width: extent.width,
3448            height: extent.height,
3449            depth: depth,
3450        }
3451    }
3452}
3453
3454/// See [`VkImageFormatProperties`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageFormatProperties)
3455#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3456pub struct ImageFormatProperties {
3457    pub max_extent: Extent3D,
3458    pub max_mip_levels: u32,
3459    pub max_array_layers: u32,
3460    pub sample_counts: SampleCountFlags,
3461    pub max_resource_size: u64,
3462}
3463
3464impl<'a> From<&'a vks::core::VkImageFormatProperties> for ImageFormatProperties {
3465    fn from(properties: &'a vks::core::VkImageFormatProperties) -> Self {
3466        ImageFormatProperties {
3467            max_extent: (&properties.maxExtent).into(),
3468            max_mip_levels: properties.maxMipLevels,
3469            max_array_layers: properties.maxArrayLayers,
3470            sample_counts: SampleCountFlags::from_bits_truncate(properties.sampleCounts),
3471            max_resource_size: properties.maxResourceSize,
3472        }
3473    }
3474}
3475
3476impl<'a> From<&'a ImageFormatProperties> for vks::core::VkImageFormatProperties {
3477    fn from(properties: &'a ImageFormatProperties) -> Self {
3478        vks::core::VkImageFormatProperties {
3479            maxExtent: (&properties.max_extent).into(),
3480            maxMipLevels: properties.max_mip_levels,
3481            maxArrayLayers: properties.max_array_layers,
3482            sampleCounts: properties.sample_counts.bits(),
3483            maxResourceSize: properties.max_resource_size,
3484        }
3485    }
3486}
3487
3488/// See [`VkPhysicalDeviceLimits`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPhysicalDeviceLimits)
3489#[derive(Debug, Copy, Clone, PartialEq)]
3490pub struct PhysicalDeviceLimits {
3491    pub max_image_dimension_1d: u32,
3492    pub max_image_dimension_2d: u32,
3493    pub max_image_dimension_3d: u32,
3494    pub max_image_dimension_cube: u32,
3495    pub max_image_array_layers: u32,
3496    pub max_texel_buffer_elements: u32,
3497    pub max_uniform_buffer_range: u32,
3498    pub max_storage_buffer_range: u32,
3499    pub max_push_constants_size: u32,
3500    pub max_memory_allocation_count: u32,
3501    pub max_sampler_allocation_count: u32,
3502    pub buffer_image_granularity: u64,
3503    pub sparse_address_space_size: u64,
3504    pub max_bound_descriptor_sets: u32,
3505    pub max_per_stage_descriptor_samplers: u32,
3506    pub max_per_stage_descriptor_uniform_buffers: u32,
3507    pub max_per_stage_descriptor_storage_buffers: u32,
3508    pub max_per_stage_descriptor_sampled_images: u32,
3509    pub max_per_stage_descriptor_storage_images: u32,
3510    pub max_per_stage_descriptor_input_attachments: u32,
3511    pub max_per_stage_resources: u32,
3512    pub max_descriptor_set_samplers: u32,
3513    pub max_descriptor_set_uniform_buffers: u32,
3514    pub max_descriptor_set_uniform_buffers_dynamic: u32,
3515    pub max_descriptor_set_storage_buffers: u32,
3516    pub max_descriptor_set_storage_buffers_dynamic: u32,
3517    pub max_descriptor_set_sampled_images: u32,
3518    pub max_descriptor_set_storage_images: u32,
3519    pub max_descriptor_set_input_attachments: u32,
3520    pub max_vertex_input_attributes: u32,
3521    pub max_vertex_input_bindings: u32,
3522    pub max_vertex_input_attribute_offset: u32,
3523    pub max_vertex_input_binding_stride: u32,
3524    pub max_vertex_output_components: u32,
3525    pub max_tessellation_generation_level: u32,
3526    pub max_tessellation_patch_size: u32,
3527    pub max_tessellation_control_per_vertex_input_components: u32,
3528    pub max_tessellation_control_per_vertex_output_components: u32,
3529    pub max_tessellation_control_per_patch_output_components: u32,
3530    pub max_tessellation_control_total_output_components: u32,
3531    pub max_tessellation_evaluation_input_components: u32,
3532    pub max_tessellation_evaluation_output_components: u32,
3533    pub max_geometry_shader_invocations: u32,
3534    pub max_geometry_input_components: u32,
3535    pub max_geometry_output_components: u32,
3536    pub max_geometry_output_vertices: u32,
3537    pub max_geometry_total_output_components: u32,
3538    pub max_fragment_input_components: u32,
3539    pub max_fragment_output_attachments: u32,
3540    pub max_fragment_dual_src_attachments: u32,
3541    pub max_fragment_combined_output_resources: u32,
3542    pub max_compute_shared_memory_size: u32,
3543    pub max_compute_work_group_count: [u32; 3],
3544    pub max_compute_work_group_invocations: u32,
3545    pub max_compute_work_group_size: [u32; 3],
3546    pub sub_pixel_precision_bits: u32,
3547    pub sub_texel_precision_bits: u32,
3548    pub mipmap_precision_bits: u32,
3549    pub max_draw_indexed_index_value: u32,
3550    pub max_draw_indirect_count: u32,
3551    pub max_sampler_lod_bias: f32,
3552    pub max_sampler_anisotropy: f32,
3553    pub max_viewports: u32,
3554    pub max_viewport_dimensions: [u32; 2],
3555    pub viewport_bounds_range: [f32; 2],
3556    pub viewport_sub_pixel_bits: u32,
3557    pub min_memory_map_alignment: usize,
3558    pub min_texel_buffer_offset_alignment: u64,
3559    pub min_uniform_buffer_offset_alignment: u64,
3560    pub min_storage_buffer_offset_alignment: u64,
3561    pub min_texel_offset: i32,
3562    pub max_texel_offset: u32,
3563    pub min_texel_gather_offset: i32,
3564    pub max_texel_gather_offset: u32,
3565    pub min_interpolation_offset: f32,
3566    pub max_interpolation_offset: f32,
3567    pub sub_pixel_interpolation_offset_bits: u32,
3568    pub max_framebuffer_width: u32,
3569    pub max_framebuffer_height: u32,
3570    pub max_framebuffer_layers: u32,
3571    pub framebuffer_color_sample_counts: SampleCountFlags,
3572    pub framebuffer_depth_sample_counts: SampleCountFlags,
3573    pub framebuffer_stencil_sample_counts: SampleCountFlags,
3574    pub framebuffer_no_attachments_sample_counts: SampleCountFlags,
3575    pub max_color_attachments: u32,
3576    pub sampled_image_color_sample_counts: SampleCountFlags,
3577    pub sampled_image_integer_sample_counts: SampleCountFlags,
3578    pub sampled_image_depth_sample_counts: SampleCountFlags,
3579    pub sampled_image_stencil_sample_counts: SampleCountFlags,
3580    pub storage_image_sample_counts: SampleCountFlags,
3581    pub max_sample_mask_words: u32,
3582    pub timestamp_compute_and_graphics: bool,
3583    pub timestamp_period: f32,
3584    pub max_clip_distances: u32,
3585    pub max_cull_distances: u32,
3586    pub max_combined_clip_and_cull_distances: u32,
3587    pub discrete_queue_priorities: u32,
3588    pub point_size_range: [f32; 2],
3589    pub line_width_range: [f32; 2],
3590    pub point_size_granularity: f32,
3591    pub line_width_granularity: f32,
3592    pub strict_lines: bool,
3593    pub standard_sample_locations: bool,
3594    pub optimal_buffer_copy_offset_alignment: u64,
3595    pub optimal_buffer_copy_row_pitch_alignment: u64,
3596    pub non_coherent_atom_size: u64,
3597}
3598
3599impl<'a> From<&'a vks::core::VkPhysicalDeviceLimits> for PhysicalDeviceLimits {
3600    fn from(limits: &'a vks::core::VkPhysicalDeviceLimits) -> Self {
3601        PhysicalDeviceLimits {
3602            max_image_dimension_1d: limits.maxImageDimension1D,
3603            max_image_dimension_2d: limits.maxImageDimension2D,
3604            max_image_dimension_3d: limits.maxImageDimension3D,
3605            max_image_dimension_cube: limits.maxImageDimensionCube,
3606            max_image_array_layers: limits.maxImageArrayLayers,
3607            max_texel_buffer_elements: limits.maxTexelBufferElements,
3608            max_uniform_buffer_range: limits.maxUniformBufferRange,
3609            max_storage_buffer_range: limits.maxStorageBufferRange,
3610            max_push_constants_size: limits.maxPushConstantsSize,
3611            max_memory_allocation_count: limits.maxMemoryAllocationCount,
3612            max_sampler_allocation_count: limits.maxSamplerAllocationCount,
3613            buffer_image_granularity: limits.bufferImageGranularity,
3614            sparse_address_space_size: limits.sparseAddressSpaceSize,
3615            max_bound_descriptor_sets: limits.maxBoundDescriptorSets,
3616            max_per_stage_descriptor_samplers: limits.maxPerStageDescriptorSamplers,
3617            max_per_stage_descriptor_uniform_buffers: limits.maxPerStageDescriptorUniformBuffers,
3618            max_per_stage_descriptor_storage_buffers: limits.maxPerStageDescriptorStorageBuffers,
3619            max_per_stage_descriptor_sampled_images: limits.maxPerStageDescriptorSampledImages,
3620            max_per_stage_descriptor_storage_images: limits.maxPerStageDescriptorStorageImages,
3621            max_per_stage_descriptor_input_attachments: limits.maxPerStageDescriptorInputAttachments,
3622            max_per_stage_resources: limits.maxPerStageResources,
3623            max_descriptor_set_samplers: limits.maxDescriptorSetSamplers,
3624            max_descriptor_set_uniform_buffers: limits.maxDescriptorSetUniformBuffers,
3625            max_descriptor_set_uniform_buffers_dynamic: limits.maxDescriptorSetUniformBuffersDynamic,
3626            max_descriptor_set_storage_buffers: limits.maxDescriptorSetStorageBuffers,
3627            max_descriptor_set_storage_buffers_dynamic: limits.maxDescriptorSetStorageBuffersDynamic,
3628            max_descriptor_set_sampled_images: limits.maxDescriptorSetSampledImages,
3629            max_descriptor_set_storage_images: limits.maxDescriptorSetStorageImages,
3630            max_descriptor_set_input_attachments: limits.maxDescriptorSetInputAttachments,
3631            max_vertex_input_attributes: limits.maxVertexInputAttributes,
3632            max_vertex_input_bindings: limits.maxVertexInputBindings,
3633            max_vertex_input_attribute_offset: limits.maxVertexInputAttributeOffset,
3634            max_vertex_input_binding_stride: limits.maxVertexInputBindingStride,
3635            max_vertex_output_components: limits.maxVertexOutputComponents,
3636            max_tessellation_generation_level: limits.maxTessellationGenerationLevel,
3637            max_tessellation_patch_size: limits.maxTessellationPatchSize,
3638            max_tessellation_control_per_vertex_input_components: limits.maxTessellationControlPerVertexInputComponents,
3639            max_tessellation_control_per_vertex_output_components: limits.maxTessellationControlPerVertexOutputComponents,
3640            max_tessellation_control_per_patch_output_components: limits.maxTessellationControlPerPatchOutputComponents,
3641            max_tessellation_control_total_output_components: limits.maxTessellationControlTotalOutputComponents,
3642            max_tessellation_evaluation_input_components: limits.maxTessellationEvaluationInputComponents,
3643            max_tessellation_evaluation_output_components: limits.maxTessellationEvaluationOutputComponents,
3644            max_geometry_shader_invocations: limits.maxGeometryShaderInvocations,
3645            max_geometry_input_components: limits.maxGeometryInputComponents,
3646            max_geometry_output_components: limits.maxGeometryOutputComponents,
3647            max_geometry_output_vertices: limits.maxGeometryOutputVertices,
3648            max_geometry_total_output_components: limits.maxGeometryTotalOutputComponents,
3649            max_fragment_input_components: limits.maxFragmentInputComponents,
3650            max_fragment_output_attachments: limits.maxFragmentOutputAttachments,
3651            max_fragment_dual_src_attachments: limits.maxFragmentDualSrcAttachments,
3652            max_fragment_combined_output_resources: limits.maxFragmentCombinedOutputResources,
3653            max_compute_shared_memory_size: limits.maxComputeSharedMemorySize,
3654            max_compute_work_group_count: limits.maxComputeWorkGroupCount,
3655            max_compute_work_group_invocations: limits.maxComputeWorkGroupInvocations,
3656            max_compute_work_group_size: limits.maxComputeWorkGroupSize,
3657            sub_pixel_precision_bits: limits.subPixelPrecisionBits,
3658            sub_texel_precision_bits: limits.subTexelPrecisionBits,
3659            mipmap_precision_bits: limits.mipmapPrecisionBits,
3660            max_draw_indexed_index_value: limits.maxDrawIndexedIndexValue,
3661            max_draw_indirect_count: limits.maxDrawIndirectCount,
3662            max_sampler_lod_bias: limits.maxSamplerLodBias,
3663            max_sampler_anisotropy: limits.maxSamplerAnisotropy,
3664            max_viewports: limits.maxViewports,
3665            max_viewport_dimensions: limits.maxViewportDimensions,
3666            viewport_bounds_range: limits.viewportBoundsRange,
3667            viewport_sub_pixel_bits: limits.viewportSubPixelBits,
3668            min_memory_map_alignment: limits.minMemoryMapAlignment,
3669            min_texel_buffer_offset_alignment: limits.minTexelBufferOffsetAlignment,
3670            min_uniform_buffer_offset_alignment: limits.minUniformBufferOffsetAlignment,
3671            min_storage_buffer_offset_alignment: limits.minStorageBufferOffsetAlignment,
3672            min_texel_offset: limits.minTexelOffset,
3673            max_texel_offset: limits.maxTexelOffset,
3674            min_texel_gather_offset: limits.minTexelGatherOffset,
3675            max_texel_gather_offset: limits.maxTexelGatherOffset,
3676            min_interpolation_offset: limits.minInterpolationOffset,
3677            max_interpolation_offset: limits.maxInterpolationOffset,
3678            sub_pixel_interpolation_offset_bits: limits.subPixelInterpolationOffsetBits,
3679            max_framebuffer_width: limits.maxFramebufferWidth,
3680            max_framebuffer_height: limits.maxFramebufferHeight,
3681            max_framebuffer_layers: limits.maxFramebufferLayers,
3682            framebuffer_color_sample_counts: SampleCountFlags::from_bits_truncate(limits.framebufferColorSampleCounts),
3683            framebuffer_depth_sample_counts: SampleCountFlags::from_bits_truncate(limits.framebufferDepthSampleCounts),
3684            framebuffer_stencil_sample_counts: SampleCountFlags::from_bits_truncate(limits.framebufferStencilSampleCounts),
3685            framebuffer_no_attachments_sample_counts: SampleCountFlags::from_bits_truncate(limits.framebufferNoAttachmentsSampleCounts),
3686            max_color_attachments: limits.maxColorAttachments,
3687            sampled_image_color_sample_counts: SampleCountFlags::from_bits_truncate(limits.sampledImageColorSampleCounts),
3688            sampled_image_integer_sample_counts: SampleCountFlags::from_bits_truncate(limits.sampledImageIntegerSampleCounts),
3689            sampled_image_depth_sample_counts: SampleCountFlags::from_bits_truncate(limits.sampledImageDepthSampleCounts),
3690            sampled_image_stencil_sample_counts: SampleCountFlags::from_bits_truncate(limits.sampledImageStencilSampleCounts),
3691            storage_image_sample_counts: SampleCountFlags::from_bits_truncate(limits.storageImageSampleCounts),
3692            max_sample_mask_words: limits.maxSampleMaskWords,
3693            timestamp_compute_and_graphics: utils::from_vk_bool(limits.timestampComputeAndGraphics),
3694            timestamp_period: limits.timestampPeriod,
3695            max_clip_distances: limits.maxClipDistances,
3696            max_cull_distances: limits.maxCullDistances,
3697            max_combined_clip_and_cull_distances: limits.maxCombinedClipAndCullDistances,
3698            discrete_queue_priorities: limits.discreteQueuePriorities,
3699            point_size_range: limits.pointSizeRange,
3700            line_width_range: limits.lineWidthRange,
3701            point_size_granularity: limits.pointSizeGranularity,
3702            line_width_granularity: limits.lineWidthGranularity,
3703            strict_lines: utils::from_vk_bool(limits.strictLines),
3704            standard_sample_locations: utils::from_vk_bool(limits.standardSampleLocations),
3705            optimal_buffer_copy_offset_alignment: limits.optimalBufferCopyOffsetAlignment,
3706            optimal_buffer_copy_row_pitch_alignment: limits.optimalBufferCopyRowPitchAlignment,
3707            non_coherent_atom_size: limits.nonCoherentAtomSize,
3708        }
3709    }
3710}
3711
3712impl<'a> From<&'a PhysicalDeviceLimits> for vks::core::VkPhysicalDeviceLimits {
3713    fn from(limits: &'a PhysicalDeviceLimits) -> Self {
3714        vks::core::VkPhysicalDeviceLimits {
3715            maxImageDimension1D: limits.max_image_dimension_1d,
3716            maxImageDimension2D: limits.max_image_dimension_2d,
3717            maxImageDimension3D: limits.max_image_dimension_3d,
3718            maxImageDimensionCube: limits.max_image_dimension_cube,
3719            maxImageArrayLayers: limits.max_image_array_layers,
3720            maxTexelBufferElements: limits.max_texel_buffer_elements,
3721            maxUniformBufferRange: limits.max_uniform_buffer_range,
3722            maxStorageBufferRange: limits.max_storage_buffer_range,
3723            maxPushConstantsSize: limits.max_push_constants_size,
3724            maxMemoryAllocationCount: limits.max_memory_allocation_count,
3725            maxSamplerAllocationCount: limits.max_sampler_allocation_count,
3726            bufferImageGranularity: limits.buffer_image_granularity,
3727            sparseAddressSpaceSize: limits.sparse_address_space_size,
3728            maxBoundDescriptorSets: limits.max_bound_descriptor_sets,
3729            maxPerStageDescriptorSamplers: limits.max_per_stage_descriptor_samplers,
3730            maxPerStageDescriptorUniformBuffers: limits.max_per_stage_descriptor_uniform_buffers,
3731            maxPerStageDescriptorStorageBuffers: limits.max_per_stage_descriptor_storage_buffers,
3732            maxPerStageDescriptorSampledImages: limits.max_per_stage_descriptor_sampled_images,
3733            maxPerStageDescriptorStorageImages: limits.max_per_stage_descriptor_storage_images,
3734            maxPerStageDescriptorInputAttachments: limits.max_per_stage_descriptor_input_attachments,
3735            maxPerStageResources: limits.max_per_stage_resources,
3736            maxDescriptorSetSamplers: limits.max_descriptor_set_samplers,
3737            maxDescriptorSetUniformBuffers: limits.max_descriptor_set_uniform_buffers,
3738            maxDescriptorSetUniformBuffersDynamic: limits.max_descriptor_set_uniform_buffers_dynamic,
3739            maxDescriptorSetStorageBuffers: limits.max_descriptor_set_storage_buffers,
3740            maxDescriptorSetStorageBuffersDynamic: limits.max_descriptor_set_storage_buffers_dynamic,
3741            maxDescriptorSetSampledImages: limits.max_descriptor_set_sampled_images,
3742            maxDescriptorSetStorageImages: limits.max_descriptor_set_storage_images,
3743            maxDescriptorSetInputAttachments: limits.max_descriptor_set_input_attachments,
3744            maxVertexInputAttributes: limits.max_vertex_input_attributes,
3745            maxVertexInputBindings: limits.max_vertex_input_bindings,
3746            maxVertexInputAttributeOffset: limits.max_vertex_input_attribute_offset,
3747            maxVertexInputBindingStride: limits.max_vertex_input_binding_stride,
3748            maxVertexOutputComponents: limits.max_vertex_output_components,
3749            maxTessellationGenerationLevel: limits.max_tessellation_generation_level,
3750            maxTessellationPatchSize: limits.max_tessellation_patch_size,
3751            maxTessellationControlPerVertexInputComponents: limits.max_tessellation_control_per_vertex_input_components,
3752            maxTessellationControlPerVertexOutputComponents: limits.max_tessellation_control_per_vertex_output_components,
3753            maxTessellationControlPerPatchOutputComponents: limits.max_tessellation_control_per_patch_output_components,
3754            maxTessellationControlTotalOutputComponents: limits.max_tessellation_control_total_output_components,
3755            maxTessellationEvaluationInputComponents: limits.max_tessellation_evaluation_input_components,
3756            maxTessellationEvaluationOutputComponents: limits.max_tessellation_evaluation_output_components,
3757            maxGeometryShaderInvocations: limits.max_geometry_shader_invocations,
3758            maxGeometryInputComponents: limits.max_geometry_input_components,
3759            maxGeometryOutputComponents: limits.max_geometry_output_components,
3760            maxGeometryOutputVertices: limits.max_geometry_output_vertices,
3761            maxGeometryTotalOutputComponents: limits.max_geometry_total_output_components,
3762            maxFragmentInputComponents: limits.max_fragment_input_components,
3763            maxFragmentOutputAttachments: limits.max_fragment_output_attachments,
3764            maxFragmentDualSrcAttachments: limits.max_fragment_dual_src_attachments,
3765            maxFragmentCombinedOutputResources: limits.max_fragment_combined_output_resources,
3766            maxComputeSharedMemorySize: limits.max_compute_shared_memory_size,
3767            maxComputeWorkGroupCount: limits.max_compute_work_group_count,
3768            maxComputeWorkGroupInvocations: limits.max_compute_work_group_invocations,
3769            maxComputeWorkGroupSize: limits.max_compute_work_group_size,
3770            subPixelPrecisionBits: limits.sub_pixel_precision_bits,
3771            subTexelPrecisionBits: limits.sub_texel_precision_bits,
3772            mipmapPrecisionBits: limits.mipmap_precision_bits,
3773            maxDrawIndexedIndexValue: limits.max_draw_indexed_index_value,
3774            maxDrawIndirectCount: limits.max_draw_indirect_count,
3775            maxSamplerLodBias: limits.max_sampler_lod_bias,
3776            maxSamplerAnisotropy: limits.max_sampler_anisotropy,
3777            maxViewports: limits.max_viewports,
3778            maxViewportDimensions: limits.max_viewport_dimensions,
3779            viewportBoundsRange: limits.viewport_bounds_range,
3780            viewportSubPixelBits: limits.viewport_sub_pixel_bits,
3781            minMemoryMapAlignment: limits.min_memory_map_alignment,
3782            minTexelBufferOffsetAlignment: limits.min_texel_buffer_offset_alignment,
3783            minUniformBufferOffsetAlignment: limits.min_uniform_buffer_offset_alignment,
3784            minStorageBufferOffsetAlignment: limits.min_storage_buffer_offset_alignment,
3785            minTexelOffset: limits.min_texel_offset,
3786            maxTexelOffset: limits.max_texel_offset,
3787            minTexelGatherOffset: limits.min_texel_gather_offset,
3788            maxTexelGatherOffset: limits.max_texel_gather_offset,
3789            minInterpolationOffset: limits.min_interpolation_offset,
3790            maxInterpolationOffset: limits.max_interpolation_offset,
3791            subPixelInterpolationOffsetBits: limits.sub_pixel_interpolation_offset_bits,
3792            maxFramebufferWidth: limits.max_framebuffer_width,
3793            maxFramebufferHeight: limits.max_framebuffer_height,
3794            maxFramebufferLayers: limits.max_framebuffer_layers,
3795            framebufferColorSampleCounts: limits.framebuffer_color_sample_counts.bits(),
3796            framebufferDepthSampleCounts: limits.framebuffer_depth_sample_counts.bits(),
3797            framebufferStencilSampleCounts: limits.framebuffer_stencil_sample_counts.bits(),
3798            framebufferNoAttachmentsSampleCounts: limits.framebuffer_no_attachments_sample_counts.bits(),
3799            maxColorAttachments: limits.max_color_attachments,
3800            sampledImageColorSampleCounts: limits.sampled_image_color_sample_counts.bits(),
3801            sampledImageIntegerSampleCounts: limits.sampled_image_integer_sample_counts.bits(),
3802            sampledImageDepthSampleCounts: limits.sampled_image_depth_sample_counts.bits(),
3803            sampledImageStencilSampleCounts: limits.sampled_image_stencil_sample_counts.bits(),
3804            storageImageSampleCounts: limits.storage_image_sample_counts.bits(),
3805            maxSampleMaskWords: limits.max_sample_mask_words,
3806            timestampComputeAndGraphics: utils::to_vk_bool(limits.timestamp_compute_and_graphics),
3807            timestampPeriod: limits.timestamp_period,
3808            maxClipDistances: limits.max_clip_distances,
3809            maxCullDistances: limits.max_cull_distances,
3810            maxCombinedClipAndCullDistances: limits.max_combined_clip_and_cull_distances,
3811            discreteQueuePriorities: limits.discrete_queue_priorities,
3812            pointSizeRange: limits.point_size_range,
3813            lineWidthRange: limits.line_width_range,
3814            pointSizeGranularity: limits.point_size_granularity,
3815            lineWidthGranularity: limits.line_width_granularity,
3816            strictLines: utils::to_vk_bool(limits.strict_lines),
3817            standardSampleLocations: utils::to_vk_bool(limits.standard_sample_locations),
3818            optimalBufferCopyOffsetAlignment: limits.optimal_buffer_copy_offset_alignment,
3819            optimalBufferCopyRowPitchAlignment: limits.optimal_buffer_copy_row_pitch_alignment,
3820            nonCoherentAtomSize: limits.non_coherent_atom_size,
3821        }
3822    }
3823}
3824
3825/// See [`VkPhysicalDeviceSparseProperties`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPhysicalDeviceSparseProperties)
3826#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3827pub struct PhysicalDeviceSparseProperties {
3828    pub residency_standard_2d_block_shape: bool,
3829    pub residency_standard_2d_multisample_block_shape: bool,
3830    pub residency_standard_3d_block_shape: bool,
3831    pub residency_aligned_mip_size: bool,
3832    pub residency_non_resident_strict: bool,
3833}
3834
3835impl<'a> From<&'a vks::core::VkPhysicalDeviceSparseProperties> for PhysicalDeviceSparseProperties {
3836    fn from(properties: &'a vks::core::VkPhysicalDeviceSparseProperties) -> Self {
3837        PhysicalDeviceSparseProperties {
3838            residency_standard_2d_block_shape: utils::from_vk_bool(properties.residencyStandard2DBlockShape),
3839            residency_standard_2d_multisample_block_shape: utils::from_vk_bool(properties.residencyStandard2DMultisampleBlockShape),
3840            residency_standard_3d_block_shape: utils::from_vk_bool(properties.residencyStandard3DBlockShape),
3841            residency_aligned_mip_size: utils::from_vk_bool(properties.residencyAlignedMipSize),
3842            residency_non_resident_strict: utils::from_vk_bool(properties.residencyNonResidentStrict),
3843        }
3844    }
3845}
3846
3847impl<'a> From<&'a PhysicalDeviceSparseProperties> for vks::core::VkPhysicalDeviceSparseProperties {
3848    fn from(properties: &'a PhysicalDeviceSparseProperties) -> Self {
3849        vks::core::VkPhysicalDeviceSparseProperties {
3850            residencyStandard2DBlockShape: utils::to_vk_bool(properties.residency_standard_2d_block_shape),
3851            residencyStandard2DMultisampleBlockShape: utils::to_vk_bool(properties.residency_standard_2d_multisample_block_shape),
3852            residencyStandard3DBlockShape: utils::to_vk_bool(properties.residency_standard_3d_block_shape),
3853            residencyAlignedMipSize: utils::to_vk_bool(properties.residency_aligned_mip_size),
3854            residencyNonResidentStrict: utils::to_vk_bool(properties.residency_non_resident_strict),
3855        }
3856    }
3857}
3858
3859/// See [`VkPhysicalDeviceProperties`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPhysicalDeviceProperties)
3860#[derive(Debug, Clone, PartialEq)]
3861pub struct PhysicalDeviceProperties {
3862    pub api_version: Version,
3863    pub driver_version: u32,
3864    pub vendor_id: u32,
3865    pub device_id: u32,
3866    pub device_type: PhysicalDeviceType,
3867    pub device_name: String,
3868    pub pipeline_cache_uuid: [u8; 16],
3869    pub limits: PhysicalDeviceLimits,
3870    pub sparse_properties: PhysicalDeviceSparseProperties,
3871}
3872
3873impl<'a> From<&'a vks::core::VkPhysicalDeviceProperties> for PhysicalDeviceProperties {
3874    fn from(properties: &'a vks::core::VkPhysicalDeviceProperties) -> Self {
3875        let device_name = unsafe {
3876            CStr::from_ptr(properties.deviceName.as_ptr()).to_str().unwrap().to_owned()
3877        };
3878
3879        PhysicalDeviceProperties {
3880            api_version: Version::from_api_version(properties.apiVersion),
3881            driver_version: properties.driverVersion,
3882            vendor_id: properties.vendorID,
3883            device_id: properties.deviceID,
3884            device_type: properties.deviceType.into(),
3885            device_name: device_name,
3886            pipeline_cache_uuid: properties.pipelineCacheUUID,
3887            limits: (&properties.limits).into(),
3888            sparse_properties: (&properties.sparseProperties).into(),
3889        }
3890    }
3891}
3892
3893impl<'a> From<&'a PhysicalDeviceProperties> for vks::core::VkPhysicalDeviceProperties {
3894    fn from(properties: &'a PhysicalDeviceProperties) -> Self {
3895        debug_assert!(properties.device_name.len() < vks::core::VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
3896
3897        let device_name = unsafe {
3898            let mut device_name: [c_char; vks::core::VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] = mem::uninitialized();
3899            ptr::copy_nonoverlapping(properties.device_name.as_ptr(), device_name.as_mut_ptr() as *mut _, properties.device_name.len());
3900            device_name[properties.device_name.len()] = 0;
3901            device_name
3902        };
3903
3904        vks::core::VkPhysicalDeviceProperties {
3905            apiVersion: properties.api_version.as_api_version(),
3906            driverVersion: properties.driver_version,
3907            vendorID: properties.vendor_id,
3908            deviceID: properties.device_id,
3909            deviceType: properties.device_type.into(),
3910            deviceName: device_name,
3911            pipelineCacheUUID: properties.pipeline_cache_uuid,
3912            limits: (&properties.limits).into(),
3913            sparseProperties: (&properties.sparse_properties).into(),
3914        }
3915    }
3916}
3917
3918/// See [`VkQueueFamilyProperties`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkQueueFamilyProperties)
3919#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3920pub struct QueueFamilyProperties {
3921    pub queue_flags: QueueFlags,
3922    pub queue_count: u32,
3923    pub timestamp_valid_bits: u32,
3924    pub min_image_transfer_granularity: Extent3D,
3925}
3926
3927impl<'a> From<&'a vks::core::VkQueueFamilyProperties> for QueueFamilyProperties {
3928    fn from(properties: &'a vks::core::VkQueueFamilyProperties) -> Self {
3929        QueueFamilyProperties {
3930            queue_flags: QueueFlags::from_bits_truncate(properties.queueFlags),
3931            queue_count: properties.queueCount,
3932            timestamp_valid_bits: properties.timestampValidBits,
3933            min_image_transfer_granularity: (&properties.minImageTransferGranularity).into(),
3934        }
3935    }
3936}
3937
3938impl<'a> From<&'a QueueFamilyProperties> for vks::core::VkQueueFamilyProperties {
3939    fn from(properties: &'a QueueFamilyProperties) -> Self {
3940        vks::core::VkQueueFamilyProperties {
3941            queueFlags: properties.queue_flags.bits(),
3942            queueCount: properties.queue_count,
3943            timestampValidBits: properties.timestamp_valid_bits,
3944            minImageTransferGranularity: (&properties.min_image_transfer_granularity).into(),
3945        }
3946    }
3947}
3948
3949/// See [`VkMemoryType`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryType)
3950#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3951pub struct MemoryType {
3952    pub property_flags: MemoryPropertyFlags,
3953    pub heap_index: u32,
3954}
3955
3956impl<'a> From<&'a vks::core::VkMemoryType> for MemoryType {
3957    fn from(memory_type: &'a vks::core::VkMemoryType) -> Self {
3958        MemoryType {
3959            property_flags: MemoryPropertyFlags::from_bits_truncate(memory_type.propertyFlags),
3960            heap_index: memory_type.heapIndex,
3961        }
3962    }
3963}
3964
3965impl<'a> From<&'a MemoryType> for vks::core::VkMemoryType {
3966    fn from(memory_type: &'a MemoryType) -> Self {
3967        vks::core::VkMemoryType {
3968            propertyFlags: memory_type.property_flags.bits(),
3969            heapIndex: memory_type.heap_index,
3970        }
3971    }
3972}
3973
3974/// See [`VkMemoryHeap`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryHeap)
3975#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3976pub struct MemoryHeap {
3977    pub size: u64,
3978    pub flags: MemoryHeapFlags,
3979}
3980
3981impl<'a> From<&'a vks::core::VkMemoryHeap> for MemoryHeap {
3982    fn from(heap: &'a vks::core::VkMemoryHeap) -> Self {
3983        MemoryHeap {
3984            size: heap.size,
3985            flags: MemoryHeapFlags::from_bits_truncate(heap.flags),
3986        }
3987    }
3988}
3989
3990impl<'a> From<&'a MemoryHeap> for vks::core::VkMemoryHeap {
3991    fn from(heap: &'a MemoryHeap) -> Self {
3992        vks::core::VkMemoryHeap {
3993            size: heap.size,
3994            flags: heap.flags.bits(),
3995        }
3996    }
3997}
3998
3999/// See [`VkPhysicalDeviceMemoryProperties`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPhysicalDeviceMemoryProperties)
4000#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4001pub struct PhysicalDeviceMemoryProperties {
4002    pub memory_types: Vec<MemoryType>,
4003    pub memory_heaps: Vec<MemoryHeap>,
4004}
4005
4006impl<'a> From<&'a vks::core::VkPhysicalDeviceMemoryProperties> for PhysicalDeviceMemoryProperties {
4007    fn from(properties: &'a vks::core::VkPhysicalDeviceMemoryProperties) -> Self {
4008        let memory_types = properties.memoryTypes[..properties.memoryTypeCount as usize]
4009            .iter()
4010            .map(From::from)
4011            .collect();
4012
4013        let memory_heaps = properties.memoryHeaps[..properties.memoryHeapCount as usize]
4014            .iter()
4015            .map(From::from)
4016            .collect();
4017
4018        PhysicalDeviceMemoryProperties {
4019            memory_types: memory_types,
4020            memory_heaps: memory_heaps,
4021        }
4022    }
4023}
4024
4025impl<'a> From<&'a PhysicalDeviceMemoryProperties> for vks::core::VkPhysicalDeviceMemoryProperties {
4026    fn from(properties: &'a PhysicalDeviceMemoryProperties) -> Self {
4027        debug_assert!(properties.memory_types.len() <= vks::core::VK_MAX_MEMORY_TYPES);
4028        debug_assert!(properties.memory_heaps.len() <= vks::core::VK_MAX_MEMORY_HEAPS);
4029
4030        let mut res = vks::core::VkPhysicalDeviceMemoryProperties {
4031            memoryTypeCount: properties.memory_types.len() as u32,
4032            memoryTypes: unsafe { mem::uninitialized() },
4033            memoryHeapCount: properties.memory_heaps.len() as u32,
4034            memoryHeaps: unsafe { mem::uninitialized() },
4035        };
4036
4037        for (vk_memory_type, memory_type) in res.memoryTypes.iter_mut().zip(&properties.memory_types) {
4038            *vk_memory_type = memory_type.into();
4039        }
4040
4041        for (vk_memory_heap, memory_heap) in res.memoryHeaps.iter_mut().zip(&properties.memory_heaps) {
4042            *vk_memory_heap = memory_heap.into();
4043        }
4044
4045        res
4046    }
4047}
4048
4049gen_chain_struct! {
4050    name: DeviceQueueCreateInfoChain [DeviceQueueCreateInfoChainWrapper],
4051    query: DeviceQueueCreateInfoChainQuery [DeviceQueueCreateInfoChainQueryWrapper],
4052    vks: vks::core::VkDeviceQueueCreateInfo,
4053    input: true,
4054    output: false,
4055}
4056
4057/// See [`VkDeviceQueueCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDeviceQueueCreateInfo)
4058#[derive(Debug, Clone, PartialEq)]
4059pub struct DeviceQueueCreateInfo {
4060    pub flags: DeviceQueueCreateFlags,
4061    pub queue_family_index: u32,
4062    pub queue_priorities: Vec<f32>,
4063    pub chain: Option<DeviceQueueCreateInfoChain>,
4064}
4065
4066#[derive(Debug)]
4067struct VkDeviceQueueCreateInfoWrapper {
4068    pub vks_struct: vks::core::VkDeviceQueueCreateInfo,
4069    queue_priorities: Vec<f32>,
4070    chain: Option<DeviceQueueCreateInfoChainWrapper>,
4071}
4072
4073impl VkDeviceQueueCreateInfoWrapper {
4074    pub fn new(create_info: &DeviceQueueCreateInfo, with_chain: bool) -> Self {
4075        let queue_priorities = create_info.queue_priorities.clone();
4076        let (pnext, chain) = DeviceQueueCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
4077
4078        VkDeviceQueueCreateInfoWrapper {
4079            vks_struct: vks::core::VkDeviceQueueCreateInfo {
4080                sType: vks::core::VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
4081                pNext: pnext,
4082                flags: create_info.flags.bits(),
4083                queueFamilyIndex: create_info.queue_family_index,
4084                queueCount: queue_priorities.len() as u32,
4085                pQueuePriorities: queue_priorities.as_ptr(),
4086            },
4087            queue_priorities: queue_priorities,
4088            chain: chain,
4089        }
4090    }
4091}
4092
4093gen_chain_struct! {
4094    name: DeviceCreateInfoChain [DeviceCreateInfoChainWrapper],
4095    query: DeviceCreateInfoChainQuery [DeviceCreateInfoChainQueryWrapper],
4096    vks: vks::core::VkDeviceCreateInfo,
4097    input: true,
4098    output: false,
4099
4100    physical_device_features2_khr: khr_get_physical_device_properties2::PhysicalDeviceFeatures2Khr {
4101        fn_add: add_physical_device_features2_khr,
4102        fn_has: has_physical_device_features2_khr,
4103        fn_get: get_physical_device_features2_khr,
4104        wrapper: khr_get_physical_device_properties2::VkPhysicalDeviceFeatures2KHRWrapper,
4105        vks: vks::khr_get_physical_device_properties2::VkPhysicalDeviceFeatures2KHR,
4106        stype: vks::core::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
4107    }
4108}
4109
4110/// See [`VkDeviceCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDeviceCreateInfo)
4111#[derive(Debug, Clone, PartialEq)]
4112pub struct DeviceCreateInfo {
4113    pub flags: DeviceCreateFlags,
4114    pub queue_create_infos: Vec<DeviceQueueCreateInfo>,
4115    pub enabled_layers: Vec<String>,
4116    pub enabled_extensions: DeviceExtensions,
4117    pub enabled_features: Option<PhysicalDeviceFeatures>,
4118    pub chain: Option<DeviceCreateInfoChain>,
4119}
4120
4121#[derive(Debug)]
4122struct VkDeviceCreateInfoWrapper {
4123    pub vks_struct: vks::core::VkDeviceCreateInfo,
4124    queue_create_infos_wrappers: Vec<VkDeviceQueueCreateInfoWrapper>,
4125    queue_create_infos: Vec<vks::core::VkDeviceQueueCreateInfo>,
4126    enabled_layers: Vec<CString>,
4127    enabled_layers_ptrs: Vec<*const c_char>,
4128    enabled_extensions: Vec<CString>,
4129    enabled_extensions_ptrs: Vec<*const c_char>,
4130    enabled_features: Option<Box<vks::core::VkPhysicalDeviceFeatures>>,
4131    chain: Option<DeviceCreateInfoChainWrapper>,
4132}
4133
4134impl VkDeviceCreateInfoWrapper {
4135    pub fn new(create_info: &DeviceCreateInfo, with_chain: bool) -> Self {
4136        let queue_create_infos_wrappers: Vec<_> = create_info.queue_create_infos
4137            .iter()
4138            .map(|q| VkDeviceQueueCreateInfoWrapper::new(q, true))
4139            .collect();
4140
4141        let queue_create_infos: Vec<vks::core::VkDeviceQueueCreateInfo> = queue_create_infos_wrappers
4142            .iter()
4143            .map(|q| q.vks_struct)
4144            .collect();
4145
4146        let enabled_layers: Vec<_> = create_info.enabled_layers
4147            .iter()
4148            .cloned()
4149            .map(CString::new)
4150            .map(Result::unwrap)
4151            .collect();
4152        let enabled_layers_ptrs: Vec<_> = enabled_layers
4153            .iter()
4154            .map(|l| l.as_ptr())
4155            .collect();
4156        let enabled_layers_ptr = if !enabled_layers_ptrs.is_empty() {
4157            enabled_layers_ptrs.as_ptr()
4158        }
4159        else {
4160            ptr::null()
4161        };
4162
4163        let enabled_extensions = create_info.enabled_extensions.to_cstring_vec();
4164        let enabled_extensions_ptrs: Vec<_> = enabled_extensions
4165            .iter()
4166            .map(|l| l.as_ptr())
4167            .collect();
4168        let enabled_extensions_ptr = if !enabled_extensions_ptrs.is_empty() {
4169            enabled_extensions_ptrs.as_ptr()
4170        }
4171        else {
4172            ptr::null()
4173        };
4174
4175        let enabled_features_ptr;
4176        let enabled_features = match create_info.enabled_features {
4177            Some(ref enabled_features) => {
4178                let enabled_features: Box<vks::core::VkPhysicalDeviceFeatures> = Box::new(enabled_features.into());
4179                enabled_features_ptr = &*enabled_features as *const _;
4180                Some(enabled_features)
4181            }
4182
4183            None => {
4184                enabled_features_ptr = ptr::null();
4185                None
4186            }
4187        };
4188
4189        let (pnext, chain) = DeviceCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
4190
4191        VkDeviceCreateInfoWrapper {
4192            vks_struct: vks::core::VkDeviceCreateInfo {
4193                sType: vks::core::VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
4194                pNext: pnext,
4195                flags: create_info.flags.bits(),
4196                queueCreateInfoCount: queue_create_infos.len() as u32,
4197                pQueueCreateInfos: queue_create_infos.as_ptr(),
4198                enabledLayerCount: enabled_layers.len() as u32,
4199                ppEnabledLayerNames: enabled_layers_ptr,
4200                enabledExtensionCount: enabled_extensions.len() as u32,
4201                ppEnabledExtensionNames: enabled_extensions_ptr,
4202                pEnabledFeatures: enabled_features_ptr,
4203            },
4204            queue_create_infos_wrappers: queue_create_infos_wrappers,
4205            queue_create_infos: queue_create_infos,
4206            enabled_layers: enabled_layers,
4207            enabled_layers_ptrs: enabled_layers_ptrs,
4208            enabled_extensions: enabled_extensions,
4209            enabled_extensions_ptrs: enabled_extensions_ptrs,
4210            enabled_features: enabled_features,
4211            chain: chain,
4212        }
4213    }
4214}
4215
4216gen_extension_structs!{
4217    pub struct InstanceExtensions;
4218    pub struct InstanceExtensionsProperties;
4219
4220    ext_debug_report {
4221        name: vks::ext_debug_report::VK_EXT_DEBUG_REPORT_EXTENSION_NAME_STR,
4222        fn_add: add_ext_debug_report,
4223        fn_has: has_ext_debug_report,
4224        fn_get: get_ext_debug_report,
4225        load_instance: load_ext_debug_report,
4226    }
4227
4228    ext_validation_flags {
4229        name: vks::ext_validation_flags::VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME_STR,
4230        fn_add: add_ext_validation_flags,
4231        fn_has: has_ext_validation_flags,
4232        fn_get: get_ext_validation_flags,
4233    }
4234
4235    khr_android_surface {
4236        name: vks::khr_android_surface::VK_KHR_ANDROID_SURFACE_EXTENSION_NAME_STR,
4237        fn_add: add_khr_android_surface,
4238        fn_has: has_khr_android_surface,
4239        fn_get: get_khr_android_surface,
4240        load_instance: load_khr_android_surface,
4241    }
4242
4243    khr_display {
4244        name: vks::khr_display::VK_KHR_DISPLAY_EXTENSION_NAME_STR,
4245        fn_add: add_khr_display,
4246        fn_has: has_khr_display,
4247        fn_get: get_khr_display,
4248        load_instance: load_khr_display,
4249    }
4250
4251    khr_get_physical_device_properties2 {
4252        name: vks::khr_get_physical_device_properties2::VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME_STR,
4253        fn_add: add_khr_get_physical_device_properties2,
4254        fn_has: has_khr_get_physical_device_properties2,
4255        fn_get: get_khr_get_physical_device_properties2,
4256        load_instance: load_khr_get_physical_device_properties2,
4257    }
4258
4259    khr_mir_surface {
4260        name: vks::khr_mir_surface::VK_KHR_MIR_SURFACE_EXTENSION_NAME_STR,
4261        fn_add: add_khr_mir_surface,
4262        fn_has: has_khr_mir_surface,
4263        fn_get: get_khr_mir_surface,
4264        load_instance: load_khr_mir_surface,
4265    }
4266
4267    khr_surface {
4268        name: vks::khr_surface::VK_KHR_SURFACE_EXTENSION_NAME_STR,
4269        fn_add: add_khr_surface,
4270        fn_has: has_khr_surface,
4271        fn_get: get_khr_surface,
4272        load_instance: load_khr_surface,
4273    }
4274
4275    khr_wayland_surface {
4276        name: vks::khr_wayland_surface::VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME_STR,
4277        fn_add: add_khr_wayland_surface,
4278        fn_has: has_khr_wayland_surface,
4279        fn_get: get_khr_wayland_surface,
4280        load_instance: load_khr_wayland_surface,
4281    }
4282
4283    khr_win32_surface {
4284        name: vks::khr_win32_surface::VK_KHR_WIN32_SURFACE_EXTENSION_NAME_STR,
4285        fn_add: add_khr_win32_surface,
4286        fn_has: has_khr_win32_surface,
4287        fn_get: get_khr_win32_surface,
4288        load_instance: load_khr_win32_surface,
4289    }
4290
4291    khr_xcb_surface {
4292        name: vks::khr_xcb_surface::VK_KHR_XCB_SURFACE_EXTENSION_NAME_STR,
4293        fn_add: add_khr_xcb_surface,
4294        fn_has: has_khr_xcb_surface,
4295        fn_get: get_khr_xcb_surface,
4296        load_instance: load_khr_xcb_surface,
4297    }
4298
4299    khr_xlib_surface {
4300        name: vks::khr_xlib_surface::VK_KHR_XLIB_SURFACE_EXTENSION_NAME_STR,
4301        fn_add: add_khr_xlib_surface,
4302        fn_has: has_khr_xlib_surface,
4303        fn_get: get_khr_xlib_surface,
4304        load_instance: load_khr_xlib_surface,
4305    }
4306
4307    nv_external_memory_capabilities {
4308        name: vks::nv_external_memory_capabilities::VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME_STR,
4309        fn_add: add_nv_external_memory_capabilities,
4310        fn_has: has_nv_external_memory_capabilities,
4311        fn_get: get_nv_external_memory_capabilities,
4312        load_instance: load_nv_external_memory_capabilities,
4313    }
4314}
4315
4316gen_extension_structs!{
4317    pub struct DeviceExtensions;
4318    pub struct DeviceExtensionsProperties;
4319
4320    amd_draw_indirect_count {
4321        name: vks::amd_draw_indirect_count::VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME_STR,
4322        fn_add: add_amd_draw_indirect_count,
4323        fn_has: has_amd_draw_indirect_count,
4324        fn_get: get_amd_draw_indirect_count,
4325        load_device: load_amd_draw_indirect_count,
4326    }
4327
4328    amd_gcn_shader {
4329        name: vks::amd_gcn_shader::VK_AMD_GCN_SHADER_EXTENSION_NAME_STR,
4330        fn_add: add_amd_gcn_shader,
4331        fn_has: has_amd_gcn_shader,
4332        fn_get: get_amd_gcn_shader,
4333    }
4334
4335    amd_gpu_shader_half_float {
4336        name: vks::amd_gpu_shader_half_float::VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME_STR,
4337        fn_add: add_amd_gpu_shader_half_float,
4338        fn_has: has_amd_gpu_shader_half_float,
4339        fn_get: get_amd_gpu_shader_half_float,
4340    }
4341
4342    amd_rasterization_order {
4343        name: vks::amd_rasterization_order::VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME_STR,
4344        fn_add: add_amd_rasterization_order,
4345        fn_has: has_amd_rasterization_order,
4346        fn_get: get_amd_rasterization_order,
4347    }
4348
4349    amd_shader_explicit_vertex_parameter {
4350        name: vks::amd_shader_explicit_vertex_parameter::VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME_STR,
4351        fn_add: add_amd_shader_explicit_vertex_parameter,
4352        fn_has: has_amd_shader_explicit_vertex_parameter,
4353        fn_get: get_amd_shader_explicit_vertex_parameter,
4354    }
4355
4356    amd_shader_trinary_minmax {
4357        name: vks::amd_shader_trinary_minmax::VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME_STR,
4358        fn_add: add_amd_shader_trinary_minmax,
4359        fn_has: has_amd_shader_trinary_minmax,
4360        fn_get: get_amd_shader_trinary_minmax,
4361    }
4362
4363    ext_debug_marker {
4364        name: vks::ext_debug_marker::VK_EXT_DEBUG_MARKER_EXTENSION_NAME_STR,
4365        fn_add: add_ext_debug_marker,
4366        fn_has: has_ext_debug_marker,
4367        fn_get: get_ext_debug_marker,
4368        load_device: load_ext_debug_marker,
4369    }
4370
4371    img_filter_cubic {
4372        name: vks::img_filter_cubic::VK_IMG_FILTER_CUBIC_EXTENSION_NAME_STR,
4373        fn_add: add_img_filter_cubic,
4374        fn_has: has_img_filter_cubic,
4375        fn_get: get_img_filter_cubic,
4376    }
4377
4378    img_format_pvrtc {
4379        name: vks::img_format_pvrtc::VK_IMG_FORMAT_PVRTC_EXTENSION_NAME_STR,
4380        fn_add: add_img_format_pvrtc,
4381        fn_has: has_img_format_pvrtc,
4382        fn_get: get_img_format_pvrtc,
4383    }
4384
4385    khr_swapchain {
4386        name: vks::khr_swapchain::VK_KHR_SWAPCHAIN_EXTENSION_NAME_STR,
4387        fn_add: add_khr_swapchain,
4388        fn_has: has_khr_swapchain,
4389        fn_get: get_khr_swapchain,
4390        load_device: load_khr_swapchain,
4391    }
4392
4393    khr_display_swapchain {
4394        name: vks::khr_display_swapchain::VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME_STR,
4395        fn_add: add_khr_display_swapchain,
4396        fn_has: has_khr_display_swapchain,
4397        fn_get: get_khr_display_swapchain,
4398        load_device: load_khr_display_swapchain,
4399    }
4400
4401    khr_sampler_mirror_clamp_to_edge {
4402        name: vks::khr_sampler_mirror_clamp_to_edge::VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME_STR,
4403        fn_add: add_khr_sampler_mirror_clamp_to_edge,
4404        fn_has: has_khr_sampler_mirror_clamp_to_edge,
4405        fn_get: get_khr_sampler_mirror_clamp_to_edge,
4406    }
4407
4408    nv_dedicated_allocation {
4409        name: vks::nv_dedicated_allocation::VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME_STR,
4410        fn_add: add_nv_dedicated_allocation,
4411        fn_has: has_nv_dedicated_allocation,
4412        fn_get: get_nv_dedicated_allocation,
4413    }
4414
4415    nv_external_memory {
4416        name: vks::nv_external_memory::VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME_STR,
4417        fn_add: add_nv_external_memory,
4418        fn_has: has_nv_external_memory,
4419        fn_get: get_nv_external_memory,
4420    }
4421
4422    nv_external_memory_win32 {
4423        name: vks::nv_external_memory_win32::VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME_STR,
4424        fn_add: add_nv_external_memory_win32,
4425        fn_has: has_nv_external_memory_win32,
4426        fn_get: get_nv_external_memory_win32,
4427        load_device: load_nv_external_memory_win32,
4428    }
4429
4430    nv_glsl_shader {
4431        name: vks::nv_glsl_shader::VK_NV_GLSL_SHADER_EXTENSION_NAME_STR,
4432        fn_add: add_nv_glsl_shader,
4433        fn_has: has_nv_glsl_shader,
4434        fn_get: get_nv_glsl_shader,
4435    }
4436
4437    nv_win32_keyed_mutex {
4438        name: vks::nv_win32_keyed_mutex::VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME_STR,
4439        fn_add: add_nv_win32_keyed_mutex,
4440        fn_has: has_nv_win32_keyed_mutex,
4441        fn_get: get_nv_win32_keyed_mutex,
4442    }
4443}
4444
4445/// See [`VkLayerProperties`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkLayerProperties)
4446#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4447pub struct LayerProperties {
4448    pub layer_name: String,
4449    pub spec_version: Version,
4450    pub implementation_version: u32,
4451    pub description: String,
4452}
4453
4454impl<'a> From<&'a vks::core::VkLayerProperties> for LayerProperties {
4455    fn from(layer_properties: &'a vks::core::VkLayerProperties) -> Self {
4456        unsafe {
4457            LayerProperties {
4458                layer_name: CStr::from_ptr(layer_properties.layerName.as_ptr()).to_str().unwrap().to_owned(),
4459                spec_version: Version::from_api_version(layer_properties.specVersion),
4460                implementation_version: layer_properties.implementationVersion,
4461                description: CStr::from_ptr(layer_properties.description.as_ptr()).to_str().unwrap().to_owned(),
4462            }
4463        }
4464    }
4465}
4466
4467gen_chain_struct! {
4468    name: SubmitInfoChain [SubmitInfoChainWrapper],
4469    query: SubmitInfoChainQuery [SubmitInfoChainQueryWrapper],
4470    vks: vks::core::VkSubmitInfo,
4471    input: true,
4472    output: false,
4473
4474    win32_keyed_mutex_acquire_release_info_nv: nv_win32_keyed_mutex::Win32KeyedMutexAcquireReleaseInfoNv {
4475        fn_add: add_win32_keyed_mutex_acquire_release_info_nv,
4476        fn_has: has_win32_keyed_mutex_acquire_release_info_nv,
4477        fn_get: get_win32_keyed_mutex_acquire_release_info_nv,
4478        wrapper: nv_win32_keyed_mutex::VkWin32KeyedMutexAcquireReleaseInfoNVWrapper,
4479        vks: vks::nv_win32_keyed_mutex::VkWin32KeyedMutexAcquireReleaseInfoNV,
4480        stype: vks::core::VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
4481    }
4482}
4483
4484/// See [`VkSubmitInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSubmitInfo)
4485#[derive(Debug, Clone, PartialEq)]
4486pub struct SubmitInfo {
4487    pub wait_semaphores: Vec<Semaphore>,
4488    pub wait_dst_stage_mask: Vec<PipelineStageFlags>,
4489    pub command_buffers: Vec<CommandBuffer>,
4490    pub signal_semaphores: Vec<Semaphore>,
4491    pub chain: Option<SubmitInfoChain>,
4492}
4493
4494#[derive(Debug)]
4495struct VkSubmitInfoWrapper {
4496    pub vks_struct: vks::core::VkSubmitInfo,
4497    wait_semaphores: Vec<Semaphore>,
4498    wait_vk_semaphores: Vec<vks::core::VkSemaphore>,
4499    wait_dst_stage_mask: Vec<vks::core::VkPipelineStageFlags>,
4500    command_buffers: Vec<CommandBuffer>,
4501    vk_command_buffers: Vec<vks::core::VkCommandBuffer>,
4502    signal_semaphores: Vec<Semaphore>,
4503    signal_vk_semaphores: Vec<vks::core::VkSemaphore>,
4504    chain: Option<SubmitInfoChainWrapper>,
4505}
4506
4507impl VkSubmitInfoWrapper {
4508    pub fn new(info: &SubmitInfo, with_chain: bool) -> Self {
4509        let wait_semaphores = info.wait_semaphores.clone();
4510        let (wait_vk_semaphores_ptr, wait_vk_semaphores) = if !wait_semaphores.is_empty() {
4511            let wait_vk_semaphores: Vec<_> = wait_semaphores.iter().map(Semaphore::handle).collect();
4512            (wait_vk_semaphores.as_ptr(), wait_vk_semaphores)
4513        }
4514        else {
4515            (ptr::null(), vec![])
4516        };
4517
4518        let wait_dst_stage_mask: Vec<_> = info.wait_dst_stage_mask.iter().map(PipelineStageFlags::bits).collect();
4519
4520        let command_buffers = info.command_buffers.clone();
4521        let (vk_command_buffers_ptr, vk_command_buffers) = if !command_buffers.is_empty() {
4522            let vk_command_buffers: Vec<_> = command_buffers.iter().map(CommandBuffer::handle).collect();
4523            (vk_command_buffers.as_ptr(), vk_command_buffers)
4524        }
4525        else {
4526            (ptr::null(), vec![])
4527        };
4528
4529        let signal_semaphores = info.signal_semaphores.clone();
4530        let (signal_vk_semaphores_ptr, signal_vk_semaphores) = if !signal_semaphores.is_empty() {
4531            let signal_vk_semaphores: Vec<_> = signal_semaphores.iter().map(Semaphore::handle).collect();
4532            (signal_vk_semaphores.as_ptr(), signal_vk_semaphores)
4533        }
4534        else {
4535            (ptr::null(), vec![])
4536        };
4537
4538        let (pnext, chain) = SubmitInfoChainWrapper::new_optional(&info.chain, with_chain);
4539
4540        VkSubmitInfoWrapper {
4541            vks_struct: vks::core::VkSubmitInfo {
4542                sType: vks::core::VK_STRUCTURE_TYPE_SUBMIT_INFO,
4543                pNext: pnext,
4544                waitSemaphoreCount: wait_semaphores.len() as u32,
4545                pWaitSemaphores: wait_vk_semaphores_ptr,
4546                pWaitDstStageMask: wait_dst_stage_mask.as_ptr(),
4547                commandBufferCount: command_buffers.len() as u32,
4548                pCommandBuffers: vk_command_buffers_ptr,
4549                signalSemaphoreCount: signal_semaphores.len() as u32,
4550                pSignalSemaphores: signal_vk_semaphores_ptr,
4551            },
4552            wait_semaphores: wait_semaphores,
4553            wait_vk_semaphores: wait_vk_semaphores,
4554            wait_dst_stage_mask: wait_dst_stage_mask,
4555            command_buffers: command_buffers,
4556            vk_command_buffers: vk_command_buffers,
4557            signal_semaphores: signal_semaphores,
4558            signal_vk_semaphores: signal_vk_semaphores,
4559            chain: chain,
4560        }
4561    }
4562}
4563
4564gen_chain_struct! {
4565    name: MemoryAllocateInfoChain [MemoryAllocateInfoChainWrapper],
4566    query: MemoryAllocateInfoChainQuery [MemoryAllocateInfoChainQueryWrapper],
4567    vks: vks::core::VkMemoryAllocateInfo,
4568    input: true,
4569    output: false,
4570
4571    dedicated_allocation_memory_allocate_info_nv: nv_dedicated_allocation::DedicatedAllocationMemoryAllocateInfoNv {
4572        fn_add: add_dedicated_allocation_memory_allocate_info_nv,
4573        fn_has: has_dedicated_allocation_memory_allocate_info_nv,
4574        fn_get: get_dedicated_allocation_memory_allocate_info_nv,
4575        wrapper: nv_dedicated_allocation::VkDedicatedAllocationMemoryAllocateInfoNVWrapper,
4576        vks: vks::nv_dedicated_allocation::VkDedicatedAllocationMemoryAllocateInfoNV,
4577        stype: vks::core::VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
4578    }
4579
4580    export_memory_allocate_info_nv: nv_external_memory::ExportMemoryAllocateInfoNv {
4581        fn_add: add_export_memory_allocate_info_nv,
4582        fn_has: has_export_memory_allocate_info_nv,
4583        fn_get: get_export_memory_allocate_info_nv,
4584        wrapper: nv_external_memory::VkExportMemoryAllocateInfoNVWrapper,
4585        vks: vks::nv_external_memory::VkExportMemoryAllocateInfoNV,
4586        stype: vks::core::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,
4587    }
4588
4589    import_memory_win32_handle_info_nv: nv_external_memory_win32::ImportMemoryWin32HandleInfoNv {
4590        fn_add: add_import_memory_win32_handle_info_nv,
4591        fn_has: has_import_memory_win32_handle_info_nv,
4592        fn_get: get_import_memory_win32_handle_info_nv,
4593        wrapper: nv_external_memory_win32::VkImportMemoryWin32HandleInfoNVWrapper,
4594        vks: vks::nv_external_memory_win32::VkImportMemoryWin32HandleInfoNV,
4595        stype: vks::core::VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
4596    }
4597
4598    export_memory_win32_handle_info_nv: nv_external_memory_win32::ExportMemoryWin32HandleInfoNv {
4599        fn_add: add_export_memory_win32_handle_info_nv,
4600        fn_has: has_export_memory_win32_handle_info_nv,
4601        fn_get: get_export_memory_win32_handle_info_nv,
4602        wrapper: nv_external_memory_win32::VkExportMemoryWin32HandleInfoNVWrapper,
4603        vks: vks::nv_external_memory_win32::VkExportMemoryWin32HandleInfoNV,
4604        stype: vks::core::VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
4605    }
4606}
4607
4608/// See [`VkMemoryAllocateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryAllocateInfo)
4609#[derive(Debug, Clone, PartialEq)]
4610pub struct MemoryAllocateInfo {
4611    pub allocation_size: u64,
4612    pub memory_type_index: u32,
4613    pub chain: Option<MemoryAllocateInfoChain>,
4614}
4615
4616#[derive(Debug)]
4617struct VkMemoryAllocateInfoWrapper {
4618    pub vks_struct: vks::core::VkMemoryAllocateInfo,
4619    chain: Option<MemoryAllocateInfoChainWrapper>,
4620}
4621
4622impl VkMemoryAllocateInfoWrapper {
4623    pub fn new(info: &MemoryAllocateInfo, with_chain: bool) -> Self {
4624        let (pnext, chain) = MemoryAllocateInfoChainWrapper::new_optional(&info.chain, with_chain);
4625
4626        VkMemoryAllocateInfoWrapper {
4627            vks_struct: vks::core::VkMemoryAllocateInfo {
4628                sType: vks::core::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
4629                pNext: pnext,
4630                allocationSize: info.allocation_size,
4631                memoryTypeIndex: info.memory_type_index,
4632            },
4633            chain: chain,
4634        }
4635    }
4636}
4637
4638gen_chain_struct! {
4639    name: MappedMemoryRangeChain [MappedMemoryRangeChainWrapper],
4640    query: MappedMemoryRangeChainQuery [MappedMemoryRangeChainQueryWrapper],
4641    vks: vks::core::VkMappedMemoryRange,
4642    input: true,
4643    output: false,
4644}
4645
4646/// See [`VkMappedMemoryRange`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMappedMemoryRange)
4647#[derive(Debug, Clone, PartialEq)]
4648pub struct MappedMemoryRange {
4649    pub memory: DeviceMemory,
4650    pub offset: u64,
4651    pub size: OptionalDeviceSize,
4652    pub chain: Option<MappedMemoryRangeChain>,
4653}
4654
4655#[derive(Debug)]
4656struct VkMappedMemoryRangeWrapper {
4657    pub vks_struct: vks::core::VkMappedMemoryRange,
4658    memory: DeviceMemory,
4659    chain: Option<MappedMemoryRangeChainWrapper>,
4660}
4661
4662impl VkMappedMemoryRangeWrapper {
4663    pub fn new(range: &MappedMemoryRange, with_chain: bool) -> Self {
4664        let (pnext, chain) = MappedMemoryRangeChainWrapper::new_optional(&range.chain, with_chain);
4665
4666        VkMappedMemoryRangeWrapper {
4667            vks_struct: vks::core::VkMappedMemoryRange {
4668                sType: vks::core::VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
4669                pNext: pnext,
4670                memory: range.memory.handle(),
4671                offset: range.offset,
4672                size: range.size.into(),
4673            },
4674            memory: range.memory.clone(),
4675            chain: chain,
4676        }
4677    }
4678}
4679
4680/// See [`VkMemoryRequirements`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryRequirements)
4681#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
4682pub struct MemoryRequirements {
4683    pub size: u64,
4684    pub alignment: u64,
4685    pub memory_type_bits: u32,
4686}
4687
4688impl<'a> From<&'a vks::core::VkMemoryRequirements> for MemoryRequirements {
4689    fn from(requirements: &'a vks::core::VkMemoryRequirements) -> Self {
4690        MemoryRequirements {
4691            size: requirements.size,
4692            alignment: requirements.alignment,
4693            memory_type_bits: requirements.memoryTypeBits,
4694        }
4695    }
4696}
4697
4698impl<'a> From<&'a MemoryRequirements> for vks::core::VkMemoryRequirements {
4699    fn from(requirements: &'a MemoryRequirements) -> Self {
4700        vks::core::VkMemoryRequirements {
4701            size: requirements.size,
4702            alignment: requirements.alignment,
4703            memoryTypeBits: requirements.memory_type_bits,
4704        }
4705    }
4706}
4707
4708/// See [`VkSparseImageFormatProperties`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseImageFormatProperties)
4709#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
4710pub struct SparseImageFormatProperties {
4711    pub aspect_mask: ImageAspectFlags,
4712    pub image_granularity: Extent3D,
4713    pub flags: SparseImageFormatFlags,
4714}
4715
4716impl<'a> From<&'a vks::core::VkSparseImageFormatProperties> for SparseImageFormatProperties {
4717    fn from(properties: &'a vks::core::VkSparseImageFormatProperties) -> Self {
4718        SparseImageFormatProperties {
4719            aspect_mask: ImageAspectFlags::from_bits_truncate(properties.aspectMask),
4720            image_granularity: (&properties.imageGranularity).into(),
4721            flags: SparseImageFormatFlags::from_bits_truncate(properties.flags),
4722        }
4723    }
4724}
4725
4726/// See [`VkSparseImageMemoryRequirements`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseImageMemoryRequirements)
4727#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
4728pub struct SparseImageMemoryRequirements {
4729    pub format_properties: SparseImageFormatProperties,
4730    pub image_mip_tail_first_lod: u32,
4731    pub image_mip_tail_size: u64,
4732    pub image_mip_tail_offset: u64,
4733    pub image_mip_tail_stride: u64,
4734}
4735
4736impl<'a> From<&'a vks::core::VkSparseImageMemoryRequirements> for SparseImageMemoryRequirements {
4737    fn from(requirements: &'a vks::core::VkSparseImageMemoryRequirements) -> Self {
4738        SparseImageMemoryRequirements {
4739            format_properties: (&requirements.formatProperties).into(),
4740            image_mip_tail_first_lod: requirements.imageMipTailFirstLod,
4741            image_mip_tail_size: requirements.imageMipTailSize,
4742            image_mip_tail_offset: requirements.imageMipTailOffset,
4743            image_mip_tail_stride: requirements.imageMipTailStride,
4744        }
4745    }
4746}
4747
4748/// See [`VkSparseMemoryBind`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseMemoryBind)
4749#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4750pub struct SparseMemoryBind {
4751    pub resource_offset: u64,
4752    pub size: u64,
4753    pub memory: Option<DeviceMemory>,
4754    pub memory_offset: u64,
4755    pub flags: SparseMemoryBindFlags,
4756}
4757
4758#[derive(Debug)]
4759struct VkSparseMemoryBindWrapper {
4760    pub vks_struct: vks::core::VkSparseMemoryBind,
4761    memory: Option<DeviceMemory>,
4762}
4763
4764impl<'a> From<&'a SparseMemoryBind> for VkSparseMemoryBindWrapper {
4765    fn from(bind: &'a SparseMemoryBind) -> Self {
4766        let (vk_memory, memory) = match bind.memory {
4767            Some(ref memory) => (memory.handle(), Some(memory.clone())),
4768            None => (Default::default(), None),
4769        };
4770
4771        VkSparseMemoryBindWrapper {
4772            vks_struct: vks::core::VkSparseMemoryBind {
4773                resourceOffset: bind.resource_offset,
4774                size: bind.size,
4775                memory: vk_memory,
4776                memoryOffset: bind.memory_offset,
4777                flags: bind.flags.bits(),
4778            },
4779            memory: memory,
4780        }
4781    }
4782}
4783
4784/// See [`VkSparseBufferMemoryBindInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseBufferMemoryBindInfo)
4785#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4786pub struct SparseBufferMemoryBindInfo {
4787    pub buffer: Buffer,
4788    pub binds: Vec<SparseMemoryBind>,
4789}
4790
4791#[derive(Debug)]
4792struct VkSparseBufferMemoryBindInfoWrapper {
4793    pub vks_struct: vks::core::VkSparseBufferMemoryBindInfo,
4794    buffer: Buffer,
4795    binds: Vec<VkSparseMemoryBindWrapper>,
4796    binds_vk: Vec<vks::core::VkSparseMemoryBind>,
4797}
4798
4799impl<'a> From<&'a SparseBufferMemoryBindInfo> for VkSparseBufferMemoryBindInfoWrapper {
4800    fn from(info: &'a SparseBufferMemoryBindInfo) -> Self {
4801        let binds: Vec<VkSparseMemoryBindWrapper> = info.binds.iter().map(From::from).collect();
4802        let binds_vk: Vec<_> = binds.iter().map(|b| b.vks_struct).collect();
4803
4804        VkSparseBufferMemoryBindInfoWrapper {
4805            vks_struct: vks::core::VkSparseBufferMemoryBindInfo {
4806                buffer: info.buffer.handle(),
4807                bindCount: binds.len() as u32,
4808                pBinds: binds_vk.as_ptr(),
4809            },
4810            buffer: info.buffer.clone(),
4811            binds: binds,
4812            binds_vk: binds_vk,
4813        }
4814    }
4815}
4816
4817/// See [`VkSparseImageOpaqueMemoryBindInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseImageOpaqueMemoryBindInfo)
4818#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4819pub struct SparseImageOpaqueMemoryBindInfo {
4820    pub image: Image,
4821    pub binds: Vec<SparseMemoryBind>,
4822}
4823
4824#[derive(Debug)]
4825struct VkSparseImageOpaqueMemoryBindInfoWrapper {
4826    pub vks_struct: vks::core::VkSparseImageOpaqueMemoryBindInfo,
4827    image: Image,
4828    binds: Vec<VkSparseMemoryBindWrapper>,
4829    binds_vk: Vec<vks::core::VkSparseMemoryBind>,
4830}
4831
4832impl<'a> From<&'a SparseImageOpaqueMemoryBindInfo> for VkSparseImageOpaqueMemoryBindInfoWrapper {
4833    fn from(info: &'a SparseImageOpaqueMemoryBindInfo) -> Self {
4834        let binds: Vec<VkSparseMemoryBindWrapper> = info.binds.iter().map(From::from).collect();
4835        let binds_vk: Vec<_> = binds.iter().map(|b| b.vks_struct).collect();
4836
4837        VkSparseImageOpaqueMemoryBindInfoWrapper {
4838            vks_struct: vks::core::VkSparseImageOpaqueMemoryBindInfo {
4839                image: info.image.handle(),
4840                bindCount: binds.len() as u32,
4841                pBinds: binds_vk.as_ptr(),
4842            },
4843            image: info.image.clone(),
4844            binds: binds,
4845            binds_vk: binds_vk,
4846        }
4847    }
4848}
4849
4850/// See [`VkImageSubresource`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageSubresource)
4851#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
4852pub struct ImageSubresource {
4853    pub aspect_mask: ImageAspectFlags,
4854    pub mip_level: u32,
4855    pub array_layer: u32,
4856}
4857
4858impl<'a> From<&'a ImageSubresource> for vks::core::VkImageSubresource {
4859    fn from(subresource: &'a ImageSubresource) -> Self {
4860        vks::core::VkImageSubresource {
4861            aspectMask: subresource.aspect_mask.bits(),
4862            mipLevel: subresource.mip_level,
4863            arrayLayer: subresource.array_layer,
4864        }
4865    }
4866}
4867
4868/// See [`VkOffset3D`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkOffset3D)
4869#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
4870pub struct Offset3D {
4871    pub x: i32,
4872    pub y: i32,
4873    pub z: i32,
4874}
4875
4876impl<'a> From<&'a Offset3D> for vks::core::VkOffset3D {
4877    fn from(offset: &'a Offset3D) -> Self {
4878        vks::core::VkOffset3D {
4879            x: offset.x,
4880            y: offset.y,
4881            z: offset.z,
4882        }
4883    }
4884}
4885
4886impl Offset3D {
4887    /// Creates a new `Offset3D`.
4888    #[inline]
4889    pub fn new(x: i32, y: i32, z: i32) -> Self {
4890        Offset3D {
4891            x: x,
4892            y: y,
4893            z: z,
4894        }
4895    }
4896
4897    /// Creates an `Offset3D` with all components set to 0.
4898    #[inline]
4899    pub fn zero() -> Self {
4900        Offset3D {
4901            x: 0,
4902            y: 0,
4903            z: 0,
4904        }
4905    }
4906
4907    /// Creates an `Offset3D` from an `Offset2D` and the specified `z` component.
4908    #[inline]
4909    pub fn from_2d(offset: &Offset2D, z: i32) -> Self {
4910        Offset3D {
4911            x: offset.x,
4912            y: offset.y,
4913            z: z,
4914        }
4915    }
4916}
4917
4918/// See [`VkSparseImageMemoryBind`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseImageMemoryBind)
4919#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4920pub struct SparseImageMemoryBind {
4921    pub subresource: ImageSubresource,
4922    pub offset: Offset3D,
4923    pub extent: Extent3D,
4924    pub memory: Option<DeviceMemory>,
4925    pub memory_offset: u64,
4926    pub flags: SparseMemoryBindFlags,
4927}
4928
4929#[derive(Debug)]
4930struct VkSparseImageMemoryBindWrapper {
4931    pub vks_struct: vks::core::VkSparseImageMemoryBind,
4932    memory: Option<DeviceMemory>,
4933}
4934
4935impl<'a> From<&'a SparseImageMemoryBind> for VkSparseImageMemoryBindWrapper {
4936    fn from(bind: &'a SparseImageMemoryBind) -> Self {
4937        let (vk_memory, memory) = match bind.memory {
4938            Some(ref memory) => (memory.handle(), Some(memory.clone())),
4939            None => (Default::default(), None),
4940        };
4941
4942        VkSparseImageMemoryBindWrapper {
4943            vks_struct: vks::core::VkSparseImageMemoryBind {
4944                subresource: (&bind.subresource).into(),
4945                offset: (&bind.offset).into(),
4946                extent: (&bind.extent).into(),
4947                memory: vk_memory,
4948                memoryOffset: bind.memory_offset,
4949                flags: bind.flags.bits(),
4950            },
4951            memory: memory,
4952        }
4953    }
4954}
4955
4956/// See [`VkSparseImageMemoryBindInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSparseImageMemoryBindInfo)
4957#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4958pub struct SparseImageMemoryBindInfo {
4959    pub image: Image,
4960    pub binds: Vec<SparseImageMemoryBind>,
4961}
4962
4963#[derive(Debug)]
4964struct VkSparseImageMemoryBindInfoWrapper {
4965    pub vks_struct: vks::core::VkSparseImageMemoryBindInfo,
4966    image: Image,
4967    binds: Vec<VkSparseImageMemoryBindWrapper>,
4968    binds_vk: Vec<vks::core::VkSparseImageMemoryBind>,
4969}
4970
4971impl<'a> From<&'a SparseImageMemoryBindInfo> for VkSparseImageMemoryBindInfoWrapper {
4972    fn from(info: &'a SparseImageMemoryBindInfo) -> Self {
4973        let binds: Vec<VkSparseImageMemoryBindWrapper> = info.binds.iter().map(From::from).collect();
4974        let binds_vk: Vec<_> = binds.iter().map(|b| b.vks_struct).collect();
4975
4976        VkSparseImageMemoryBindInfoWrapper {
4977            vks_struct: vks::core::VkSparseImageMemoryBindInfo {
4978                image: info.image.handle(),
4979                bindCount: binds.len() as u32,
4980                pBinds: binds_vk.as_ptr(),
4981            },
4982            image: info.image.clone(),
4983            binds: binds,
4984            binds_vk: binds_vk,
4985        }
4986    }
4987}
4988
4989gen_chain_struct! {
4990    name: BindSparseInfoChain [BindSparseInfoChainWrapper],
4991    query: BindSparseInfoChainQuery [BindSparseInfoChainQueryWrapper],
4992    vks: vks::core::VkBindSparseInfo,
4993    input: true,
4994    output: false,
4995}
4996
4997/// See [`VkBindSparseInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBindSparseInfo)
4998#[derive(Debug, Clone, PartialEq)]
4999pub struct BindSparseInfo {
5000    pub wait_semaphores: Vec<Semaphore>,
5001    pub buffer_binds: Vec<SparseBufferMemoryBindInfo>,
5002    pub image_opaque_binds: Vec<SparseImageOpaqueMemoryBindInfo>,
5003    pub image_binds: Vec<SparseImageMemoryBindInfo>,
5004    pub signal_semaphores: Vec<Semaphore>,
5005    pub chain: Option<BindSparseInfoChain>,
5006}
5007
5008#[derive(Debug)]
5009struct VkBindSparseInfoWrapper {
5010    pub vks_struct: vks::core::VkBindSparseInfo,
5011    wait_semaphores: Vec<Semaphore>,
5012    wait_vk_semaphores: Vec<vks::core::VkSemaphore>,
5013    buffer_binds: Vec<VkSparseBufferMemoryBindInfoWrapper>,
5014    vk_buffer_binds: Vec<vks::core::VkSparseBufferMemoryBindInfo>,
5015    image_opaque_binds: Vec<VkSparseImageOpaqueMemoryBindInfoWrapper>,
5016    vk_image_opaque_binds: Vec<vks::core::VkSparseImageOpaqueMemoryBindInfo>,
5017    image_binds: Vec<VkSparseImageMemoryBindInfoWrapper>,
5018    vk_image_binds: Vec<vks::core::VkSparseImageMemoryBindInfo>,
5019    signal_semaphores: Vec<Semaphore>,
5020    signal_vk_semaphores: Vec<vks::core::VkSemaphore>,
5021    chain: Option<BindSparseInfoChainWrapper>,
5022}
5023
5024impl VkBindSparseInfoWrapper {
5025    pub fn new(info: &BindSparseInfo, with_chain: bool) -> Self {
5026        let wait_semaphores = info.wait_semaphores.clone();
5027        let (wait_vk_semaphores_ptr, wait_vk_semaphores) = if !wait_semaphores.is_empty() {
5028            let wait_vk_semaphores: Vec<_> = wait_semaphores.iter().map(Semaphore::handle).collect();
5029            (wait_vk_semaphores.as_ptr(), wait_vk_semaphores)
5030        }
5031        else {
5032            (ptr::null(), vec![])
5033        };
5034
5035        let buffer_binds: Vec<VkSparseBufferMemoryBindInfoWrapper> = info.buffer_binds.iter().map(From::from).collect();
5036        let (vk_buffer_binds_ptr, vk_buffer_binds) = if !buffer_binds.is_empty() {
5037            let vk_buffer_binds: Vec<_> = buffer_binds.iter().map(|b| b.vks_struct).collect();
5038            (vk_buffer_binds.as_ptr(), vk_buffer_binds)
5039        }
5040        else {
5041            (ptr::null(), vec![])
5042        };
5043
5044        let image_opaque_binds: Vec<VkSparseImageOpaqueMemoryBindInfoWrapper> = info.image_opaque_binds.iter().map(From::from).collect();
5045        let (vk_image_opaque_binds_ptr, vk_image_opaque_binds) = if !image_opaque_binds.is_empty() {
5046            let vk_image_opaque_binds: Vec<_> = image_opaque_binds.iter().map(|i| i.vks_struct).collect();
5047            (vk_image_opaque_binds.as_ptr(), vk_image_opaque_binds)
5048        }
5049        else {
5050            (ptr::null(), vec![])
5051        };
5052
5053        let image_binds: Vec<VkSparseImageMemoryBindInfoWrapper> = info.image_binds.iter().map(From::from).collect();
5054        let (vk_image_binds_ptr, vk_image_binds) = if !image_binds.is_empty() {
5055            let vk_image_binds: Vec<_> = image_binds.iter().map(|i| i.vks_struct).collect();
5056            (vk_image_binds.as_ptr(), vk_image_binds)
5057        }
5058        else {
5059            (ptr::null(), vec![])
5060        };
5061
5062        let signal_semaphores = info.signal_semaphores.clone();
5063        let (signal_vk_semaphores_ptr, signal_vk_semaphores) = if !signal_semaphores.is_empty() {
5064            let signal_vk_semaphores: Vec<_> = signal_semaphores.iter().map(Semaphore::handle).collect();
5065            (signal_vk_semaphores.as_ptr(), signal_vk_semaphores)
5066        }
5067        else {
5068            (ptr::null(), vec![])
5069        };
5070
5071        let (pnext, chain) = BindSparseInfoChainWrapper::new_optional(&info.chain, with_chain);
5072
5073        VkBindSparseInfoWrapper {
5074            vks_struct: vks::core::VkBindSparseInfo {
5075                sType: vks::core::VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
5076                pNext: pnext,
5077                waitSemaphoreCount: wait_semaphores.len() as u32,
5078                pWaitSemaphores: wait_vk_semaphores_ptr,
5079                bufferBindCount: buffer_binds.len() as u32,
5080                pBufferBinds: vk_buffer_binds_ptr,
5081                imageOpaqueBindCount: image_opaque_binds.len() as u32,
5082                pImageOpaqueBinds: vk_image_opaque_binds_ptr,
5083                imageBindCount: image_binds.len() as u32,
5084                pImageBinds: vk_image_binds_ptr,
5085                signalSemaphoreCount: signal_semaphores.len() as u32,
5086                pSignalSemaphores: signal_vk_semaphores_ptr,
5087            },
5088            wait_semaphores: wait_semaphores,
5089            wait_vk_semaphores: wait_vk_semaphores,
5090            buffer_binds: buffer_binds,
5091            vk_buffer_binds: vk_buffer_binds,
5092            image_opaque_binds: image_opaque_binds,
5093            vk_image_opaque_binds: vk_image_opaque_binds,
5094            image_binds: image_binds,
5095            vk_image_binds: vk_image_binds,
5096            signal_semaphores: signal_semaphores,
5097            signal_vk_semaphores: signal_vk_semaphores,
5098            chain: chain,
5099        }
5100    }
5101}
5102
5103gen_chain_struct! {
5104    name: FenceCreateInfoChain [FenceCreateInfoChainWrapper],
5105    query: FenceCreateInfoChainQuery [FenceCreateInfoChainQueryWrapper],
5106    vks: vks::core::VkFenceCreateInfo,
5107    input: true,
5108    output: false,
5109}
5110
5111/// See [`VkFenceCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFenceCreateInfo)
5112#[derive(Debug, Clone, PartialEq)]
5113pub struct FenceCreateInfo {
5114    pub flags: FenceCreateFlags,
5115    pub chain: Option<FenceCreateInfoChain>,
5116}
5117
5118#[derive(Debug)]
5119struct VkFenceCreateInfoWrapper {
5120    pub vks_struct: vks::core::VkFenceCreateInfo,
5121    chain: Option<FenceCreateInfoChainWrapper>,
5122}
5123
5124impl VkFenceCreateInfoWrapper {
5125    pub fn new(create_info: &FenceCreateInfo, with_chain: bool) -> Self {
5126        let (pnext, chain) = FenceCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5127
5128        VkFenceCreateInfoWrapper {
5129            vks_struct: vks::core::VkFenceCreateInfo {
5130                sType: vks::core::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
5131                pNext: pnext,
5132                flags: create_info.flags.bits(),
5133            },
5134            chain: chain,
5135        }
5136    }
5137}
5138
5139gen_chain_struct! {
5140    name: SemaphoreCreateInfoChain [SemaphoreCreateInfoChainWrapper],
5141    query: SemaphoreCreateInfoChainQuery [SemaphoreCreateInfoChainQueryWrapper],
5142    vks: vks::core::VkSemaphoreCreateInfo,
5143    input: true,
5144    output: false,
5145}
5146
5147/// See [`VkSemaphoreCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSemaphoreCreateInfo)
5148#[derive(Debug, Clone, PartialEq)]
5149pub struct SemaphoreCreateInfo {
5150    pub flags: SemaphoreCreateFlags,
5151    pub chain: Option<SemaphoreCreateInfoChain>,
5152}
5153
5154#[derive(Debug)]
5155struct VkSemaphoreCreateInfoWrapper {
5156    pub vks_struct: vks::core::VkSemaphoreCreateInfo,
5157    chain: Option<SemaphoreCreateInfoChainWrapper>,
5158}
5159
5160impl VkSemaphoreCreateInfoWrapper {
5161    pub fn new(create_info: &SemaphoreCreateInfo, with_chain: bool) -> Self {
5162        let (pnext, chain) = SemaphoreCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5163
5164        VkSemaphoreCreateInfoWrapper {
5165            vks_struct: vks::core::VkSemaphoreCreateInfo {
5166                sType: vks::core::VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
5167                pNext: pnext,
5168                flags: create_info.flags.bits(),
5169            },
5170            chain: chain,
5171        }
5172    }
5173}
5174
5175gen_chain_struct! {
5176    name: EventCreateInfoChain [EventCreateInfoChainWrapper],
5177    query: EventCreateInfoChainQuery [EventCreateInfoChainQueryWrapper],
5178    vks: vks::core::VkEventCreateInfo,
5179    input: true,
5180    output: false,
5181}
5182
5183/// See [`VkEventCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkEventCreateInfo)
5184#[derive(Debug, Clone, PartialEq)]
5185pub struct EventCreateInfo {
5186    pub flags: EventCreateFlags,
5187    pub chain: Option<EventCreateInfoChain>,
5188}
5189
5190#[derive(Debug)]
5191struct VkEventCreateInfoWrapper {
5192    pub vks_struct: vks::core::VkEventCreateInfo,
5193    chain: Option<EventCreateInfoChainWrapper>,
5194}
5195
5196impl VkEventCreateInfoWrapper {
5197    pub fn new(create_info: &EventCreateInfo, with_chain: bool) -> Self {
5198        let (pnext, chain) = EventCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5199
5200        VkEventCreateInfoWrapper {
5201            vks_struct: vks::core::VkEventCreateInfo {
5202                sType: vks::core::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
5203                pNext: pnext,
5204                flags: create_info.flags.bits(),
5205            },
5206            chain: chain,
5207        }
5208    }
5209}
5210
5211gen_chain_struct! {
5212    name: QueryPoolCreateInfoChain [QueryPoolCreateInfoChainWrapper],
5213    query: QueryPoolCreateInfoChainQuery [QueryPoolCreateInfoChainQueryWrapper],
5214    vks: vks::core::VkQueryPoolCreateInfo,
5215    input: true,
5216    output: false,
5217}
5218
5219/// See [`VkQueryPoolCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkQueryPoolCreateInfo)
5220#[derive(Debug, Clone, PartialEq)]
5221pub struct QueryPoolCreateInfo {
5222    pub flags: QueryPoolCreateFlags,
5223    pub query_type: QueryType,
5224    pub query_count: u32,
5225    pub pipeline_statistics: QueryPipelineStatisticFlags,
5226    pub chain: Option<QueryPoolCreateInfoChain>,
5227}
5228
5229#[derive(Debug)]
5230struct VkQueryPoolCreateInfoWrapper {
5231    pub vks_struct: vks::core::VkQueryPoolCreateInfo,
5232    chain: Option<QueryPoolCreateInfoChainWrapper>,
5233}
5234
5235impl VkQueryPoolCreateInfoWrapper {
5236    pub fn new(create_info: &QueryPoolCreateInfo, with_chain: bool) -> Self {
5237        let (pnext, chain) = QueryPoolCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5238
5239        VkQueryPoolCreateInfoWrapper {
5240            vks_struct: vks::core::VkQueryPoolCreateInfo {
5241                sType: vks::core::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
5242                pNext: pnext,
5243                flags: create_info.flags.bits(),
5244                queryType: create_info.query_type.into(),
5245                queryCount: create_info.query_count,
5246                pipelineStatistics: create_info.pipeline_statistics.bits(),
5247            },
5248            chain: chain,
5249        }
5250    }
5251}
5252
5253gen_chain_struct! {
5254    name: BufferCreateInfoChain [BufferCreateInfoChainWrapper],
5255    query: BufferCreateInfoChainQuery [BufferCreateInfoChainQueryWrapper],
5256    vks: vks::core::VkBufferCreateInfo,
5257    input: true,
5258    output: false,
5259
5260    dedicated_allocation_buffer_create_info_nv: nv_dedicated_allocation::DedicatedAllocationBufferCreateInfoNv {
5261        fn_add: add_dedicated_allocation_buffer_create_info_nv,
5262        fn_has: has_dedicated_allocation_buffer_create_info_nv,
5263        fn_get: get_dedicated_allocation_buffer_create_info_nv,
5264        wrapper: nv_dedicated_allocation::VkDedicatedAllocationBufferCreateInfoNVWrapper,
5265        vks: vks::nv_dedicated_allocation::VkDedicatedAllocationBufferCreateInfoNV,
5266        stype: vks::core::VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
5267    }
5268}
5269
5270/// See [`VkBufferCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBufferCreateInfo)
5271#[derive(Debug, Clone, PartialEq)]
5272pub struct BufferCreateInfo {
5273    pub flags: BufferCreateFlags,
5274    pub size: u64,
5275    pub usage: BufferUsageFlags,
5276    pub sharing_mode: SharingMode,
5277    pub queue_family_indices: Vec<u32>,
5278    pub chain: Option<BufferCreateInfoChain>,
5279}
5280
5281#[derive(Debug)]
5282struct VkBufferCreateInfoWrapper {
5283    pub vks_struct: vks::core::VkBufferCreateInfo,
5284    queue_family_indices: Vec<u32>,
5285    chain: Option<BufferCreateInfoChainWrapper>,
5286}
5287
5288impl VkBufferCreateInfoWrapper {
5289    pub fn new(create_info: &BufferCreateInfo, with_chain: bool) -> Self {
5290        let queue_family_indices = create_info.queue_family_indices.clone();
5291        let queue_family_indices_ptr = if !queue_family_indices.is_empty() {
5292            queue_family_indices.as_ptr()
5293        }
5294        else {
5295            ptr::null()
5296        };
5297
5298        let (pnext, chain) = BufferCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5299
5300        VkBufferCreateInfoWrapper {
5301            vks_struct: vks::core::VkBufferCreateInfo {
5302                sType: vks::core::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
5303                pNext: pnext,
5304                flags: create_info.flags.bits(),
5305                size: create_info.size,
5306                usage: create_info.usage.bits(),
5307                sharingMode: create_info.sharing_mode.into(),
5308                queueFamilyIndexCount: queue_family_indices.len() as u32,
5309                pQueueFamilyIndices: queue_family_indices_ptr,
5310            },
5311            queue_family_indices: queue_family_indices,
5312            chain: chain,
5313        }
5314    }
5315}
5316
5317gen_chain_struct! {
5318    name: BufferViewCreateInfoChain [BufferViewCreateInfoChainWrapper],
5319    query: BufferViewCreateInfoChainQuery [BufferViewCreateInfoChainQueryWrapper],
5320    vks: vks::core::VkBufferViewCreateInfo,
5321    input: true,
5322    output: false,
5323}
5324
5325/// See [`VkBufferViewCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBufferViewCreateInfo)
5326#[derive(Debug, Clone, PartialEq)]
5327pub struct BufferViewCreateInfo {
5328    pub flags: BufferViewCreateFlags,
5329    pub buffer: Buffer,
5330    pub format: Format,
5331    pub offset: u64,
5332    pub range: OptionalDeviceSize,
5333    pub chain: Option<BufferViewCreateInfoChain>,
5334}
5335
5336#[derive(Debug)]
5337struct VkBufferViewCreateInfoWrapper {
5338    pub vks_struct: vks::core::VkBufferViewCreateInfo,
5339    buffer: Buffer,
5340    chain: Option<BufferViewCreateInfoChainWrapper>,
5341}
5342
5343impl VkBufferViewCreateInfoWrapper {
5344    pub fn new(create_info: &BufferViewCreateInfo, with_chain: bool) -> Self {
5345        let (pnext, chain) = BufferViewCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5346
5347        VkBufferViewCreateInfoWrapper {
5348            vks_struct: vks::core::VkBufferViewCreateInfo {
5349                sType: vks::core::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
5350                pNext: pnext,
5351                flags: create_info.flags.bits(),
5352                buffer: create_info.buffer.handle(),
5353                format: create_info.format.into(),
5354                offset: create_info.offset,
5355                range: create_info.range.into(),
5356            },
5357            buffer: create_info.buffer.clone(),
5358            chain: chain,
5359        }
5360    }
5361}
5362
5363gen_chain_struct! {
5364    name: ImageCreateInfoChain [ImageCreateInfoChainWrapper],
5365    query: ImageCreateInfoChainQuery [ImageCreateInfoChainQueryWrapper],
5366    vks: vks::core::VkImageCreateInfo,
5367    input: true,
5368    output: false,
5369
5370    dedicated_allocation_image_create_info_nv: nv_dedicated_allocation::DedicatedAllocationImageCreateInfoNv {
5371        fn_add: add_dedicated_allocation_image_create_info_nv,
5372        fn_has: has_dedicated_allocation_image_create_info_nv,
5373        fn_get: get_dedicated_allocation_image_create_info_nv,
5374        wrapper: nv_dedicated_allocation::VkDedicatedAllocationImageCreateInfoNVWrapper,
5375        vks: vks::nv_dedicated_allocation::VkDedicatedAllocationImageCreateInfoNV,
5376        stype: vks::core::VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
5377    }
5378
5379    external_memory_image_create_info_nv: nv_external_memory::ExternalMemoryImageCreateInfoNv {
5380        fn_add: add_external_memory_image_create_info_nv,
5381        fn_has: has_external_memory_image_create_info_nv,
5382        fn_get: get_external_memory_image_create_info_nv,
5383        wrapper: nv_external_memory::VkExternalMemoryImageCreateInfoNVWrapper,
5384        vks: vks::nv_external_memory::VkExternalMemoryImageCreateInfoNV,
5385        stype: vks::core::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
5386    }
5387}
5388
5389/// See [`VkImageCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageCreateInfo)
5390#[derive(Debug, Clone, PartialEq)]
5391pub struct ImageCreateInfo {
5392    pub flags: ImageCreateFlags,
5393    pub image_type: ImageType,
5394    pub format: Format,
5395    pub extent: Extent3D,
5396    pub mip_levels: u32,
5397    pub array_layers: u32,
5398    pub samples: SampleCountFlagBits,
5399    pub tiling: ImageTiling,
5400    pub usage: ImageUsageFlags,
5401    pub sharing_mode: SharingMode,
5402    pub queue_family_indices: Vec<u32>,
5403    pub initial_layout: ImageLayout,
5404    pub chain: Option<ImageCreateInfoChain>,
5405}
5406
5407#[derive(Debug)]
5408struct VkImageCreateInfoWrapper {
5409    pub vks_struct: vks::core::VkImageCreateInfo,
5410    queue_family_indices: Vec<u32>,
5411    chain: Option<ImageCreateInfoChainWrapper>,
5412}
5413
5414impl VkImageCreateInfoWrapper {
5415    pub fn new(create_info: &ImageCreateInfo, with_chain: bool) -> Self {
5416        let queue_family_indices = create_info.queue_family_indices.clone();
5417        let queue_family_indices_ptr = if !queue_family_indices.is_empty() {
5418            queue_family_indices.as_ptr()
5419        }
5420        else {
5421            ptr::null()
5422        };
5423
5424        let (pnext, chain) = ImageCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5425
5426        VkImageCreateInfoWrapper {
5427            vks_struct: vks::core::VkImageCreateInfo {
5428                sType: vks::core::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
5429                pNext: pnext,
5430                flags: create_info.flags.bits(),
5431                imageType: create_info.image_type.into(),
5432                format: create_info.format.into(),
5433                extent: (&create_info.extent).into(),
5434                mipLevels: create_info.mip_levels,
5435                arrayLayers: create_info.array_layers,
5436                samples: create_info.samples.bit(),
5437                tiling: create_info.tiling.into(),
5438                usage: create_info.usage.bits(),
5439                sharingMode: create_info.sharing_mode.into(),
5440                queueFamilyIndexCount: queue_family_indices.len() as u32,
5441                pQueueFamilyIndices: queue_family_indices_ptr,
5442                initialLayout: create_info.initial_layout.into(),
5443            },
5444            queue_family_indices: queue_family_indices,
5445            chain: chain,
5446        }
5447    }
5448}
5449
5450/// See [`VkSubresourceLayout`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSubresourceLayout)
5451#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
5452pub struct SubresourceLayout {
5453    pub offset: u64,
5454    pub size: u64,
5455    pub row_pitch: u64,
5456    pub array_pitch: u64,
5457    pub depth_pitch: u64,
5458}
5459
5460impl<'a> From<&'a vks::core::VkSubresourceLayout> for SubresourceLayout {
5461    fn from(layout: &'a vks::core::VkSubresourceLayout) -> Self {
5462        SubresourceLayout {
5463            offset: layout.offset,
5464            size: layout.size,
5465            row_pitch: layout.rowPitch,
5466            array_pitch: layout.arrayPitch,
5467            depth_pitch: layout.depthPitch,
5468        }
5469    }
5470}
5471
5472/// See [`VkComponentMapping`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkComponentMapping)
5473#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
5474pub struct ComponentMapping {
5475    pub r: ComponentSwizzle,
5476    pub g: ComponentSwizzle,
5477    pub b: ComponentSwizzle,
5478    pub a: ComponentSwizzle,
5479}
5480
5481impl<'a> From<&'a ComponentMapping> for vks::core::VkComponentMapping {
5482    fn from(mapping: &'a ComponentMapping) -> Self {
5483        vks::core::VkComponentMapping {
5484            r: mapping.r.into(),
5485            g: mapping.g.into(),
5486            b: mapping.b.into(),
5487            a: mapping.a.into(),
5488        }
5489    }
5490}
5491
5492impl ComponentMapping {
5493    /// Creates a `ComponentMapping` with all components initialized to
5494    /// `ComponentSwizzle::Identity`.
5495    #[inline]
5496    pub fn identity() -> Self {
5497        ComponentMapping {
5498            r: ComponentSwizzle::Identity,
5499            g: ComponentSwizzle::Identity,
5500            b: ComponentSwizzle::Identity,
5501            a: ComponentSwizzle::Identity,
5502        }
5503    }
5504}
5505
5506/// See [`VkImageSubresourceRange`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageSubresourceRange)
5507#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
5508pub struct ImageSubresourceRange {
5509    pub aspect_mask: ImageAspectFlags,
5510    pub base_mip_level: u32,
5511    pub level_count: OptionalMipLevels,
5512    pub base_array_layer: u32,
5513    pub layer_count: OptionalArrayLayers,
5514}
5515
5516impl<'a> From<&'a ImageSubresourceRange> for vks::core::VkImageSubresourceRange {
5517    fn from(range: &'a ImageSubresourceRange) -> Self {
5518        vks::core::VkImageSubresourceRange {
5519            aspectMask: range.aspect_mask.bits(),
5520            baseMipLevel: range.base_mip_level,
5521            levelCount: range.level_count.into(),
5522            baseArrayLayer: range.base_array_layer,
5523            layerCount: range.layer_count.into(),
5524        }
5525    }
5526}
5527
5528gen_chain_struct! {
5529    name: ImageViewCreateInfoChain [ImageViewCreateInfoChainWrapper],
5530    query: ImageViewCreateInfoChainQuery [ImageViewCreateInfoChainQueryWrapper],
5531    vks: vks::core::VkImageViewCreateInfo,
5532    input: true,
5533    output: false,
5534}
5535
5536/// See [`VkImageViewCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageViewCreateInfo)
5537#[derive(Debug, Clone, PartialEq)]
5538pub struct ImageViewCreateInfo {
5539    pub flags: ImageViewCreateFlags,
5540    pub image: Image,
5541    pub view_type: ImageViewType,
5542    pub format: Format,
5543    pub components: ComponentMapping,
5544    pub subresource_range: ImageSubresourceRange,
5545    pub chain: Option<ImageViewCreateInfoChain>,
5546}
5547
5548#[derive(Debug)]
5549struct VkImageViewCreateInfoWrapper {
5550    pub vks_struct: vks::core::VkImageViewCreateInfo,
5551    image: Image,
5552    chain: Option<ImageViewCreateInfoChainWrapper>,
5553}
5554
5555impl VkImageViewCreateInfoWrapper {
5556    pub fn new(create_info: &ImageViewCreateInfo, with_chain: bool) -> Self {
5557        let (pnext, chain) = ImageViewCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5558
5559        VkImageViewCreateInfoWrapper {
5560            vks_struct: vks::core::VkImageViewCreateInfo {
5561                sType: vks::core::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
5562                pNext: pnext,
5563                flags: create_info.flags.bits(),
5564                image: create_info.image.handle(),
5565                viewType: create_info.view_type.into(),
5566                format: create_info.format.into(),
5567                components: (&create_info.components).into(),
5568                subresourceRange: (&create_info.subresource_range).into(),
5569            },
5570            image: create_info.image.clone(),
5571            chain: chain,
5572        }
5573    }
5574}
5575
5576gen_chain_struct! {
5577    name: ShaderModuleCreateInfoChain [ShaderModuleCreateInfoChainWrapper],
5578    query: ShaderModuleCreateInfoChainQuery [ShaderModuleCreateInfoChainQueryWrapper],
5579    vks: vks::core::VkShaderModuleCreateInfo,
5580    input: true,
5581    output: false,
5582}
5583
5584/// See [`VkShaderModuleCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkShaderModuleCreateInfo)
5585#[derive(Debug, Clone, PartialEq)]
5586pub struct ShaderModuleCreateInfo {
5587    pub flags: ShaderModuleCreateFlags,
5588    pub code: Vec<u8>,
5589    pub chain: Option<ShaderModuleCreateInfoChain>,
5590}
5591
5592#[derive(Debug)]
5593struct VkShaderModuleCreateInfoWrapper {
5594    pub vks_struct: vks::core::VkShaderModuleCreateInfo,
5595    code: Vec<u32>,
5596    chain: Option<ShaderModuleCreateInfoChainWrapper>,
5597}
5598
5599impl VkShaderModuleCreateInfoWrapper {
5600    pub fn new(create_info: &ShaderModuleCreateInfo, with_chain: bool) -> Self {
5601        let size_u32 = if create_info.code.len() % mem::size_of::<u32>() == 0 {
5602            create_info.code.len() / mem::size_of::<u32>()
5603        }
5604        else {
5605            1 + create_info.code.len() / mem::size_of::<u32>()
5606        };
5607
5608        let mut code = Vec::with_capacity(size_u32);
5609        unsafe {
5610            code.set_len(size_u32);
5611            ptr::copy_nonoverlapping(create_info.code.as_ptr(), code.as_mut_ptr() as *mut u8, create_info.code.len());
5612        }
5613
5614        let (pnext, chain) = ShaderModuleCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5615
5616        VkShaderModuleCreateInfoWrapper {
5617            vks_struct: vks::core::VkShaderModuleCreateInfo {
5618                sType: vks::core::VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
5619                pNext: pnext,
5620                flags: create_info.flags.bits(),
5621                codeSize: create_info.code.len(),
5622                pCode: code.as_ptr(),
5623            },
5624            code: code,
5625            chain: chain,
5626        }
5627    }
5628}
5629
5630gen_chain_struct! {
5631    name: PipelineCacheCreateInfoChain [PipelineCacheCreateInfoChainWrapper],
5632    query: PipelineCacheCreateInfoChainQuery [PipelineCacheCreateInfoChainQueryWrapper],
5633    vks: vks::core::VkPipelineCacheCreateInfo,
5634    input: true,
5635    output: false,
5636}
5637
5638/// See [`VkPipelineCacheCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineCacheCreateInfo)
5639#[derive(Debug, Clone, PartialEq)]
5640pub struct PipelineCacheCreateInfo {
5641    pub flags: PipelineCacheCreateFlags,
5642    pub initial_data: Vec<u8>,
5643    pub chain: Option<PipelineCacheCreateInfoChain>,
5644}
5645
5646#[derive(Debug)]
5647struct VkPipelineCacheCreateInfoWrapper {
5648    pub vks_struct: vks::core::VkPipelineCacheCreateInfo,
5649    initial_data: Vec<u8>,
5650    chain: Option<PipelineCacheCreateInfoChainWrapper>,
5651}
5652
5653impl VkPipelineCacheCreateInfoWrapper {
5654    pub fn new(create_info: &PipelineCacheCreateInfo, with_chain: bool) -> Self {
5655        let initial_data = create_info.initial_data.clone();
5656        let initial_data_ptr = if !initial_data.is_empty() {
5657            initial_data.as_ptr() as *const _
5658        }
5659        else {
5660            ptr::null()
5661        };
5662
5663        let (pnext, chain) = PipelineCacheCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5664
5665        VkPipelineCacheCreateInfoWrapper {
5666            vks_struct: vks::core::VkPipelineCacheCreateInfo {
5667                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
5668                pNext: pnext,
5669                flags: create_info.flags.bits(),
5670                initialDataSize: initial_data.len(),
5671                pInitialData: initial_data_ptr,
5672            },
5673            initial_data: initial_data,
5674            chain: chain,
5675        }
5676    }
5677}
5678
5679/// See [`VkSpecializationMapEntry`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSpecializationMapEntry)
5680#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
5681pub struct SpecializationMapEntry {
5682    pub constant_id: u32,
5683    pub offset: u32,
5684    pub size: usize,
5685}
5686
5687impl<'a> From<&'a SpecializationMapEntry> for vks::core::VkSpecializationMapEntry {
5688    fn from(entry: &'a SpecializationMapEntry) -> Self {
5689        vks::core::VkSpecializationMapEntry {
5690            constantID: entry.constant_id,
5691            offset: entry.offset,
5692            size: entry.size,
5693        }
5694    }
5695}
5696
5697/// See [`VkSpecializationInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSpecializationInfo)
5698#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
5699pub struct SpecializationInfo {
5700    pub map_entries: Vec<SpecializationMapEntry>,
5701    pub data: Vec<u8>,
5702}
5703
5704impl SpecializationInfo {
5705    #[inline]
5706    pub fn new() -> Self {
5707        Default::default()
5708    }
5709
5710    pub fn push<T>(&mut self, constant_id: u32, value: T)
5711    where T: Copy
5712    {
5713        let entry = SpecializationMapEntry {
5714            constant_id: constant_id,
5715            offset: self.data.len() as u32,
5716            size: mem::size_of::<T>(),
5717        };
5718
5719        self.data.reserve(entry.size);
5720        unsafe {
5721            self.data.set_len(entry.offset as usize + entry.size);
5722            ptr::copy_nonoverlapping(&value as *const T as *const u8, self.data.as_mut_ptr().offset(entry.offset as isize), entry.size);
5723        }
5724
5725        self.map_entries.push(entry);
5726    }
5727}
5728
5729#[derive(Debug)]
5730struct VkSpecializationInfoWrapper {
5731    pub vks_struct: vks::core::VkSpecializationInfo,
5732    map_entries: Vec<vks::core::VkSpecializationMapEntry>,
5733    data: Vec<u8>,
5734}
5735
5736impl<'a> From<&'a SpecializationInfo> for VkSpecializationInfoWrapper {
5737    fn from(info: &'a SpecializationInfo) -> Self {
5738        let map_entries: Vec<_> = info.map_entries.iter().map(From::from).collect();
5739        let map_entries_ptr = if !map_entries.is_empty() {
5740            map_entries.as_ptr()
5741        }
5742        else {
5743            ptr::null()
5744        };
5745
5746        let data = info.data.clone();
5747        let data_ptr = if !data.is_empty() {
5748            data.as_ptr() as *const _
5749        }
5750        else {
5751            ptr::null()
5752        };
5753
5754        VkSpecializationInfoWrapper {
5755            vks_struct: vks::core::VkSpecializationInfo {
5756                mapEntryCount: map_entries.len() as u32,
5757                pMapEntries: map_entries_ptr,
5758                dataSize: data.len(),
5759                pData: data_ptr,
5760            },
5761            map_entries: map_entries,
5762            data: data,
5763        }
5764    }
5765}
5766
5767gen_chain_struct! {
5768    name: PipelineShaderStageCreateInfoChain [PipelineShaderStageCreateInfoChainWrapper],
5769    query: PipelineShaderStageCreateInfoChainQuery [PipelineShaderStageCreateInfoChainQueryWrapper],
5770    vks: vks::core::VkPipelineShaderStageCreateInfo,
5771    input: true,
5772    output: false,
5773}
5774
5775/// See [`VkPipelineShaderStageCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineShaderStageCreateInfo)
5776#[derive(Debug, Clone, PartialEq)]
5777pub struct PipelineShaderStageCreateInfo {
5778    pub flags: PipelineShaderStageCreateFlags,
5779    pub stage: ShaderStageFlagBits,
5780    pub module: ShaderModule,
5781    pub name: String,
5782    pub specialization_info: Option<SpecializationInfo>,
5783    pub chain: Option<PipelineShaderStageCreateInfoChain>,
5784}
5785
5786#[derive(Debug)]
5787struct VkPipelineShaderStageCreateInfoWrapper {
5788    pub vks_struct: vks::core::VkPipelineShaderStageCreateInfo,
5789    module: ShaderModule,
5790    name: CString,
5791    specialization_info: Option<Box<VkSpecializationInfoWrapper>>,
5792    chain: Option<PipelineShaderStageCreateInfoChainWrapper>,
5793}
5794
5795impl VkPipelineShaderStageCreateInfoWrapper {
5796    pub fn new(create_info: &PipelineShaderStageCreateInfo, with_chain: bool) -> Self {
5797        let name = CString::new(create_info.name.clone()).unwrap();
5798
5799        let (specialization_info_ptr, specialization_info) = match create_info.specialization_info {
5800            Some(ref specialization_info) => {
5801                let specialization_info: Box<VkSpecializationInfoWrapper> = Box::new(specialization_info.into());
5802                (&specialization_info.vks_struct as *const _, Some(specialization_info))
5803            }
5804
5805            None => (ptr::null(), None),
5806        };
5807
5808        let (pnext, chain) = PipelineShaderStageCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5809
5810        VkPipelineShaderStageCreateInfoWrapper {
5811            vks_struct: vks::core::VkPipelineShaderStageCreateInfo {
5812                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
5813                pNext: pnext,
5814                flags: create_info.flags.bits(),
5815                stage: create_info.stage.bit(),
5816                module: create_info.module.handle(),
5817                pName: name.as_ptr(),
5818                pSpecializationInfo: specialization_info_ptr,
5819            },
5820            module: create_info.module.clone(),
5821            name: name,
5822            specialization_info: specialization_info,
5823            chain: chain,
5824        }
5825    }
5826}
5827
5828/// See [`VkVertexInputBindingDescription`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkVertexInputBindingDescription)
5829#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
5830pub struct VertexInputBindingDescription {
5831    pub binding: u32,
5832    pub stride: u32,
5833    pub input_rate: VertexInputRate,
5834}
5835
5836impl<'a> From<&'a VertexInputBindingDescription> for vks::core::VkVertexInputBindingDescription {
5837    fn from(description: &'a VertexInputBindingDescription) -> Self {
5838        vks::core::VkVertexInputBindingDescription {
5839            binding: description.binding,
5840            stride: description.stride,
5841            inputRate: description.input_rate.into(),
5842        }
5843    }
5844}
5845
5846/// See [`VkVertexInputAttributeDescription`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkVertexInputAttributeDescription)
5847#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
5848pub struct VertexInputAttributeDescription {
5849    pub location: u32,
5850    pub binding: u32,
5851    pub format: Format,
5852    pub offset: u32,
5853}
5854
5855impl<'a> From<&'a VertexInputAttributeDescription> for vks::core::VkVertexInputAttributeDescription {
5856    fn from(description: &'a VertexInputAttributeDescription) -> Self {
5857        vks::core::VkVertexInputAttributeDescription {
5858            location: description.location,
5859            binding: description.binding,
5860            format: description.format.into(),
5861            offset: description.offset,
5862        }
5863    }
5864}
5865
5866gen_chain_struct! {
5867    name: PipelineVertexInputStateCreateInfoChain [PipelineVertexInputStateCreateInfoChainWrapper],
5868    query: PipelineVertexInputStateCreateInfoChainQuery [PipelineVertexInputStateCreateInfoChainQueryWrapper],
5869    vks: vks::core::VkPipelineVertexInputStateCreateInfo,
5870    input: true,
5871    output: false,
5872}
5873
5874/// See [`VkPipelineVertexInputStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineVertexInputStateCreateInfo)
5875#[derive(Debug, Clone, PartialEq)]
5876pub struct PipelineVertexInputStateCreateInfo {
5877    pub flags: PipelineVertexInputStateCreateFlags,
5878    pub vertex_binding_descriptions: Vec<VertexInputBindingDescription>,
5879    pub vertex_attribute_descriptions: Vec<VertexInputAttributeDescription>,
5880    pub chain: Option<PipelineVertexInputStateCreateInfoChain>,
5881}
5882
5883#[derive(Debug)]
5884struct VkPipelineVertexInputStateCreateInfoWrapper {
5885    pub vks_struct: vks::core::VkPipelineVertexInputStateCreateInfo,
5886    vertex_binding_descriptions: Vec<vks::core::VkVertexInputBindingDescription>,
5887    vertex_attribute_descriptions: Vec<vks::core::VkVertexInputAttributeDescription>,
5888    chain: Option<PipelineVertexInputStateCreateInfoChainWrapper>,
5889}
5890
5891impl VkPipelineVertexInputStateCreateInfoWrapper {
5892    pub fn new(create_info: &PipelineVertexInputStateCreateInfo, with_chain: bool) -> Self {
5893        let vertex_binding_descriptions: Vec<_> = create_info.vertex_binding_descriptions.iter().map(From::from).collect();
5894        let vertex_binding_descriptions_ptr = if !vertex_binding_descriptions.is_empty() {
5895            vertex_binding_descriptions.as_ptr()
5896        }
5897        else {
5898            ptr::null()
5899        };
5900
5901        let vertex_attribute_descriptions: Vec<_> = create_info.vertex_attribute_descriptions.iter().map(From::from).collect();
5902        let vertex_attribute_descriptions_ptr = if !vertex_attribute_descriptions.is_empty() {
5903            vertex_attribute_descriptions.as_ptr()
5904        }
5905        else {
5906            ptr::null()
5907        };
5908
5909        let (pnext, chain) = PipelineVertexInputStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5910
5911        VkPipelineVertexInputStateCreateInfoWrapper {
5912            vks_struct: vks::core::VkPipelineVertexInputStateCreateInfo {
5913                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
5914                pNext: pnext,
5915                flags: create_info.flags.bits(),
5916                vertexBindingDescriptionCount: vertex_binding_descriptions.len() as u32,
5917                pVertexBindingDescriptions: vertex_binding_descriptions_ptr,
5918                vertexAttributeDescriptionCount: vertex_attribute_descriptions.len() as u32,
5919                pVertexAttributeDescriptions: vertex_attribute_descriptions_ptr,
5920            },
5921            vertex_binding_descriptions: vertex_binding_descriptions,
5922            vertex_attribute_descriptions: vertex_attribute_descriptions,
5923            chain: chain,
5924        }
5925    }
5926}
5927
5928gen_chain_struct! {
5929    name: PipelineInputAssemblyStateCreateInfoChain [PipelineInputAssemblyStateCreateInfoChainWrapper],
5930    query: PipelineInputAssemblyStateCreateInfoChainQuery [PipelineInputAssemblyStateCreateInfoChainQueryWrapper],
5931    vks: vks::core::VkPipelineInputAssemblyStateCreateInfo,
5932    input: true,
5933    output: false,
5934}
5935
5936/// See [`VkPipelineInputAssemblyStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineInputAssemblyStateCreateInfo)
5937#[derive(Debug, Clone, PartialEq)]
5938pub struct PipelineInputAssemblyStateCreateInfo {
5939    pub flags: PipelineInputAssemblyStateCreateFlags,
5940    pub topology: PrimitiveTopology,
5941    pub primitive_restart_enable: bool,
5942    pub chain: Option<PipelineInputAssemblyStateCreateInfoChain>,
5943}
5944
5945#[derive(Debug)]
5946struct VkPipelineInputAssemblyStateCreateInfoWrapper {
5947    pub vks_struct: vks::core::VkPipelineInputAssemblyStateCreateInfo,
5948    chain: Option<PipelineInputAssemblyStateCreateInfoChainWrapper>,
5949}
5950
5951impl VkPipelineInputAssemblyStateCreateInfoWrapper {
5952    pub fn new(create_info: &PipelineInputAssemblyStateCreateInfo, with_chain: bool) -> Self {
5953        let (pnext, chain) = PipelineInputAssemblyStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5954
5955        VkPipelineInputAssemblyStateCreateInfoWrapper {
5956            vks_struct: vks::core::VkPipelineInputAssemblyStateCreateInfo {
5957                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
5958                pNext: pnext,
5959                flags: create_info.flags.bits(),
5960                topology: create_info.topology.into(),
5961                primitiveRestartEnable: utils::to_vk_bool(create_info.primitive_restart_enable),
5962            },
5963            chain: chain,
5964        }
5965    }
5966}
5967
5968gen_chain_struct! {
5969    name: PipelineTessellationStateCreateInfoChain [PipelineTessellationStateCreateInfoChainWrapper],
5970    query: PipelineTessellationStateCreateInfoChainQuery [PipelineTessellationStateCreateInfoChainQueryWrapper],
5971    vks: vks::core::VkPipelineTessellationStateCreateInfo,
5972    input: true,
5973    output: false,
5974}
5975
5976/// See [`VkPipelineTessellationStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineTessellationStateCreateInfo)
5977#[derive(Debug, Clone, PartialEq)]
5978pub struct PipelineTessellationStateCreateInfo {
5979    pub flags: PipelineTessellationStateCreateFlags,
5980    pub patch_control_points: u32,
5981    pub chain: Option<PipelineTessellationStateCreateInfoChain>,
5982}
5983
5984#[derive(Debug)]
5985struct VkPipelineTessellationStateCreateInfoWrapper {
5986    pub vks_struct: vks::core::VkPipelineTessellationStateCreateInfo,
5987    chain: Option<PipelineTessellationStateCreateInfoChainWrapper>,
5988}
5989
5990impl VkPipelineTessellationStateCreateInfoWrapper {
5991    pub fn new(create_info: &PipelineTessellationStateCreateInfo, with_chain: bool) -> Self {
5992        let (pnext, chain) = PipelineTessellationStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
5993
5994        VkPipelineTessellationStateCreateInfoWrapper {
5995            vks_struct: vks::core::VkPipelineTessellationStateCreateInfo {
5996                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
5997                pNext: pnext,
5998                flags: create_info.flags.bits(),
5999                patchControlPoints: create_info.patch_control_points,
6000            },
6001            chain: chain,
6002        }
6003    }
6004}
6005
6006/// See [`VkViewport`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkViewport)
6007#[derive(Debug, Copy, Clone, PartialEq)]
6008pub struct Viewport {
6009    pub x: f32,
6010    pub y: f32,
6011    pub width: f32,
6012    pub height: f32,
6013    pub min_depth: f32,
6014    pub max_depth: f32,
6015}
6016
6017impl<'a> From<&'a Viewport> for vks::core::VkViewport {
6018    fn from(viewport: &'a Viewport) -> Self {
6019        vks::core::VkViewport {
6020            x: viewport.x,
6021            y: viewport.y,
6022            width: viewport.width,
6023            height: viewport.height,
6024            minDepth: viewport.min_depth,
6025            maxDepth: viewport.max_depth,
6026        }
6027    }
6028}
6029
6030/// See [`VkOffset2D`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkOffset2D)
6031#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6032pub struct Offset2D {
6033    pub x: i32,
6034    pub y: i32,
6035}
6036
6037impl<'a> From<&'a vks::core::VkOffset2D> for Offset2D {
6038    fn from(offset: &'a vks::core::VkOffset2D) -> Self {
6039        Offset2D {
6040            x: offset.x,
6041            y: offset.y,
6042        }
6043    }
6044}
6045
6046impl<'a> From<&'a Offset2D> for vks::core::VkOffset2D {
6047    fn from(offset: &'a Offset2D) -> Self {
6048        vks::core::VkOffset2D {
6049            x: offset.x,
6050            y: offset.y,
6051        }
6052    }
6053}
6054
6055impl Offset2D {
6056    /// Creates a new `Offset2D`.
6057    #[inline]
6058    pub fn new(x: i32, y: i32) -> Self {
6059        Offset2D {
6060            x: x,
6061            y: y,
6062        }
6063    }
6064
6065    /// Creates an `Offset2D` with all components set to 0.
6066    #[inline]
6067    pub fn zero() -> Self {
6068        Offset2D {
6069            x: 0,
6070            y: 0,
6071        }
6072    }
6073
6074    /// Creates an `Offset2D` from an `Offset3D` by discarding the `z` component.
6075    #[inline]
6076    pub fn from_3d(offset: &Offset3D) -> Self {
6077        Offset2D {
6078            x: offset.x,
6079            y: offset.y,
6080        }
6081    }
6082}
6083
6084/// See [`VkExtent2D`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkExtent2D)
6085#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6086pub struct Extent2D {
6087    pub width: u32,
6088    pub height: u32,
6089}
6090
6091impl<'a> From<&'a vks::core::VkExtent2D> for Extent2D {
6092    fn from(extent: &'a vks::core::VkExtent2D) -> Self {
6093        Extent2D {
6094            width: extent.width,
6095            height: extent.height,
6096        }
6097    }
6098}
6099
6100impl<'a> From<&'a Extent2D> for vks::core::VkExtent2D {
6101    fn from(extent: &'a Extent2D) -> Self {
6102        vks::core::VkExtent2D {
6103            width: extent.width,
6104            height: extent.height,
6105        }
6106    }
6107}
6108
6109impl Extent2D {
6110    /// Creates a new `Extent2D`.
6111    #[inline]
6112    pub fn new(width: u32, height: u32) -> Self {
6113        Extent2D {
6114            width: width,
6115            height: height,
6116        }
6117    }
6118
6119    /// Creates an `Extent2D` with all components set to 0.
6120    #[inline]
6121    pub fn zero() -> Self {
6122        Extent2D {
6123            width: 0,
6124            height: 0,
6125        }
6126    }
6127
6128    /// Creates an `Extent2D` from an `Extent3D` by discarding the `depth` component.
6129    #[inline]
6130    pub fn from_3d(extent: &Extent3D) -> Self {
6131        Extent2D {
6132            width: extent.width,
6133            height: extent.height,
6134        }
6135    }
6136}
6137
6138/// See [`VkRect2D`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkRect2D)
6139#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6140pub struct Rect2D {
6141    pub offset: Offset2D,
6142    pub extent: Extent2D,
6143}
6144
6145impl<'a> From<&'a Rect2D> for vks::core::VkRect2D {
6146    fn from(rect: &'a Rect2D) -> Self {
6147        vks::core::VkRect2D {
6148            offset: (&rect.offset).into(),
6149            extent: (&rect.extent).into(),
6150        }
6151    }
6152}
6153
6154impl Rect2D {
6155    /// Creates a new `Rect2D`.
6156    #[inline]
6157    pub fn new(offset: Offset2D, extent: Extent2D) -> Self {
6158        Rect2D {
6159            offset: offset,
6160            extent: extent,
6161        }
6162    }
6163}
6164
6165gen_chain_struct! {
6166    name: PipelineViewportStateCreateInfoChain [PipelineViewportStateCreateInfoChainWrapper],
6167    query: PipelineViewportStateCreateInfoChainQuery [PipelineViewportStateCreateInfoChainQueryWrapper],
6168    vks: vks::core::VkPipelineViewportStateCreateInfo,
6169    input: true,
6170    output: false,
6171}
6172
6173/// See [`VkPipelineViewportStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineViewportStateCreateInfo)
6174#[derive(Debug, Clone, PartialEq)]
6175pub struct PipelineViewportStateCreateInfo {
6176    pub flags: PipelineViewportStateCreateFlags,
6177    pub viewports: Vec<Viewport>,
6178    pub scissors: Vec<Rect2D>,
6179    pub chain: Option<PipelineViewportStateCreateInfoChain>,
6180}
6181
6182#[derive(Debug)]
6183struct VkPipelineViewportStateCreateInfoWrapper {
6184    pub vks_struct: vks::core::VkPipelineViewportStateCreateInfo,
6185    viewports: Vec<vks::core::VkViewport>,
6186    scissors: Vec<vks::core::VkRect2D>,
6187    chain: Option<PipelineViewportStateCreateInfoChainWrapper>,
6188}
6189
6190impl VkPipelineViewportStateCreateInfoWrapper {
6191    pub fn new(create_info: &PipelineViewportStateCreateInfo, with_chain: bool) -> Self {
6192        let viewports: Vec<_> = create_info.viewports.iter().map(From::from).collect();
6193        let scissors: Vec<_> = create_info.scissors.iter().map(From::from).collect();
6194        let (pnext, chain) = PipelineViewportStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6195
6196        VkPipelineViewportStateCreateInfoWrapper {
6197            vks_struct: vks::core::VkPipelineViewportStateCreateInfo {
6198                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
6199                pNext: pnext,
6200                flags: create_info.flags.bits(),
6201                viewportCount: viewports.len() as u32,
6202                pViewports: viewports.as_ptr(),
6203                scissorCount: scissors.len() as u32,
6204                pScissors: scissors.as_ptr(),
6205            },
6206            viewports: viewports,
6207            scissors: scissors,
6208            chain: chain,
6209        }
6210    }
6211}
6212
6213gen_chain_struct! {
6214    name: PipelineRasterizationStateCreateInfoChain [PipelineRasterizationStateCreateInfoChainWrapper],
6215    query: PipelineRasterizationStateCreateInfoChainQuery [PipelineRasterizationStateCreateInfoChainQueryWrapper],
6216    vks: vks::core::VkPipelineRasterizationStateCreateInfo,
6217    input: true,
6218    output: false,
6219
6220    pipeline_rasterization_state_rasterization_order_amd: amd_rasterization_order::PipelineRasterizationStateRasterizationOrderAmd {
6221        fn_add: add_pipeline_rasterization_state_rasterization_order_amd,
6222        fn_has: has_pipeline_rasterization_state_rasterization_order_amd,
6223        fn_get: get_pipeline_rasterization_state_rasterization_order_amd,
6224        wrapper: amd_rasterization_order::VkPipelineRasterizationStateRasterizationOrderAMDWrapper,
6225        vks: vks::amd_rasterization_order::VkPipelineRasterizationStateRasterizationOrderAMD,
6226        stype: vks::core::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
6227    }
6228}
6229
6230/// See [`VkPipelineRasterizationStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineRasterizationStateCreateInfo)
6231#[derive(Debug, Clone, PartialEq)]
6232pub struct PipelineRasterizationStateCreateInfo {
6233    pub flags: PipelineRasterizationStateCreateFlags,
6234    pub depth_clamp_enable: bool,
6235    pub rasterizer_discard_enable: bool,
6236    pub polygon_mode: PolygonMode,
6237    pub cull_mode: CullModeFlags,
6238    pub front_face: FrontFace,
6239    pub depth_bias_enable: bool,
6240    pub depth_bias_constant_factor: f32,
6241    pub depth_bias_clamp: f32,
6242    pub depth_bias_slope_factor: f32,
6243    pub line_width: f32,
6244    pub chain: Option<PipelineRasterizationStateCreateInfoChain>,
6245}
6246
6247#[derive(Debug)]
6248struct VkPipelineRasterizationStateCreateInfoWrapper {
6249    pub vks_struct: vks::core::VkPipelineRasterizationStateCreateInfo,
6250    chain: Option<PipelineRasterizationStateCreateInfoChainWrapper>,
6251}
6252
6253impl VkPipelineRasterizationStateCreateInfoWrapper {
6254    pub fn new(create_info: &PipelineRasterizationStateCreateInfo, with_chain: bool) -> Self {
6255        let (pnext, chain) = PipelineRasterizationStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6256
6257        VkPipelineRasterizationStateCreateInfoWrapper {
6258            vks_struct: vks::core::VkPipelineRasterizationStateCreateInfo {
6259                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
6260                pNext: pnext,
6261                flags: create_info.flags.bits(),
6262                depthClampEnable: utils::to_vk_bool(create_info.depth_clamp_enable),
6263                rasterizerDiscardEnable: utils::to_vk_bool(create_info.rasterizer_discard_enable),
6264                polygonMode: create_info.polygon_mode.into(),
6265                cullMode: create_info.cull_mode.bits(),
6266                frontFace: create_info.front_face.into(),
6267                depthBiasEnable: utils::to_vk_bool(create_info.depth_bias_enable),
6268                depthBiasConstantFactor: create_info.depth_bias_constant_factor,
6269                depthBiasClamp: create_info.depth_bias_clamp,
6270                depthBiasSlopeFactor: create_info.depth_bias_slope_factor,
6271                lineWidth: create_info.line_width,
6272            },
6273            chain: chain,
6274        }
6275    }
6276}
6277
6278gen_chain_struct! {
6279    name: PipelineMultisampleStateCreateInfoChain [PipelineMultisampleStateCreateInfoChainWrapper],
6280    query: PipelineMultisampleStateCreateInfoChainQuery [PipelineMultisampleStateCreateInfoChainQueryWrapper],
6281    vks: vks::core::VkPipelineMultisampleStateCreateInfo,
6282    input: true,
6283    output: false,
6284}
6285
6286/// See [`VkPipelineMultisampleStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineMultisampleStateCreateInfo)
6287#[derive(Debug, Clone, PartialEq)]
6288pub struct PipelineMultisampleStateCreateInfo {
6289    pub flags: PipelineMultisampleStateCreateFlags,
6290    pub rasterization_samples: SampleCountFlagBits,
6291    pub sample_shading_enable: bool,
6292    pub min_sample_shading: f32,
6293    pub sample_mask: Vec<u32>,
6294    pub alpha_to_coverage_enable: bool,
6295    pub alpha_to_one_enable: bool,
6296    pub chain: Option<PipelineMultisampleStateCreateInfoChain>,
6297}
6298
6299#[derive(Debug)]
6300struct VkPipelineMultisampleStateCreateInfoWrapper {
6301    pub vks_struct: vks::core::VkPipelineMultisampleStateCreateInfo,
6302    sample_mask: Vec<u32>,
6303    chain: Option<PipelineMultisampleStateCreateInfoChainWrapper>,
6304}
6305
6306impl VkPipelineMultisampleStateCreateInfoWrapper {
6307    pub fn new(create_info: &PipelineMultisampleStateCreateInfo, with_chain: bool) -> Self {
6308        let sample_mask = create_info.sample_mask.clone();
6309        let sample_mask_ptr = if !sample_mask.is_empty() {
6310            sample_mask.as_ptr()
6311        }
6312        else {
6313            ptr::null()
6314        };
6315
6316        let (pnext, chain) = PipelineMultisampleStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6317
6318        VkPipelineMultisampleStateCreateInfoWrapper {
6319            vks_struct: vks::core::VkPipelineMultisampleStateCreateInfo {
6320                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
6321                pNext: pnext,
6322                flags: create_info.flags.bits(),
6323                rasterizationSamples: create_info.rasterization_samples.bit(),
6324                sampleShadingEnable: utils::to_vk_bool(create_info.sample_shading_enable),
6325                minSampleShading: create_info.min_sample_shading,
6326                pSampleMask: sample_mask_ptr,
6327                alphaToCoverageEnable: utils::to_vk_bool(create_info.alpha_to_coverage_enable),
6328                alphaToOneEnable: utils::to_vk_bool(create_info.alpha_to_one_enable),
6329            },
6330            sample_mask: sample_mask,
6331            chain: chain,
6332        }
6333    }
6334}
6335
6336/// See [`VkStencilOpState`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkStencilOpState)
6337#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6338pub struct StencilOpState {
6339    pub fail_op: StencilOp,
6340    pub pass_op: StencilOp,
6341    pub depth_fail_op: StencilOp,
6342    pub compare_op: CompareOp,
6343    pub compare_mask: u32,
6344    pub write_mask: u32,
6345    pub reference: u32,
6346}
6347
6348impl<'a> From<&'a StencilOpState> for vks::core::VkStencilOpState {
6349    fn from(state: &'a StencilOpState) -> Self {
6350        vks::core::VkStencilOpState {
6351            failOp: state.fail_op.into(),
6352            passOp: state.pass_op.into(),
6353            depthFailOp: state.depth_fail_op.into(),
6354            compareOp: state.compare_op.into(),
6355            compareMask: state.compare_mask,
6356            writeMask: state.write_mask,
6357            reference: state.reference,
6358        }
6359    }
6360}
6361
6362gen_chain_struct! {
6363    name: PipelineDepthStencilStateCreateInfoChain [PipelineDepthStencilStateCreateInfoChainWrapper],
6364    query: PipelineDepthStencilStateCreateInfoChainQuery [PipelineDepthStencilStateCreateInfoChainQueryWrapper],
6365    vks: vks::core::VkPipelineDepthStencilStateCreateInfo,
6366    input: true,
6367    output: false,
6368}
6369
6370/// See [`VkPipelineDepthStencilStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineDepthStencilStateCreateInfo)
6371#[derive(Debug, Clone, PartialEq)]
6372pub struct PipelineDepthStencilStateCreateInfo {
6373    pub flags: PipelineDepthStencilStateCreateFlags,
6374    pub depth_test_enable: bool,
6375    pub depth_write_enable: bool,
6376    pub depth_compare_op: CompareOp,
6377    pub depth_bounds_test_enable: bool,
6378    pub stencil_test_enable: bool,
6379    pub front: StencilOpState,
6380    pub back: StencilOpState,
6381    pub min_depth_bounds: f32,
6382    pub max_depth_bounds: f32,
6383    pub chain: Option<PipelineDepthStencilStateCreateInfoChain>,
6384}
6385
6386#[derive(Debug)]
6387struct VkPipelineDepthStencilStateCreateInfoWrapper {
6388    pub vks_struct: vks::core::VkPipelineDepthStencilStateCreateInfo,
6389    chain: Option<PipelineDepthStencilStateCreateInfoChainWrapper>,
6390}
6391
6392impl VkPipelineDepthStencilStateCreateInfoWrapper {
6393    pub fn new(create_info: &PipelineDepthStencilStateCreateInfo, with_chain: bool) -> Self {
6394        let (pnext, chain) = PipelineDepthStencilStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6395
6396        VkPipelineDepthStencilStateCreateInfoWrapper {
6397            vks_struct: vks::core::VkPipelineDepthStencilStateCreateInfo {
6398                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
6399                pNext: pnext,
6400                flags: create_info.flags.bits(),
6401                depthTestEnable: utils::to_vk_bool(create_info.depth_test_enable),
6402                depthWriteEnable: utils::to_vk_bool(create_info.depth_write_enable),
6403                depthCompareOp: create_info.depth_compare_op.into(),
6404                depthBoundsTestEnable: utils::to_vk_bool(create_info.depth_bounds_test_enable),
6405                stencilTestEnable: utils::to_vk_bool(create_info.stencil_test_enable),
6406                front: (&create_info.front).into(),
6407                back: (&create_info.back).into(),
6408                minDepthBounds: create_info.min_depth_bounds,
6409                maxDepthBounds: create_info.max_depth_bounds,
6410            },
6411            chain: chain,
6412        }
6413    }
6414}
6415
6416/// See [`VkPipelineColorBlendAttachmentState`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineColorBlendAttachmentState)
6417#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6418pub struct PipelineColorBlendAttachmentState {
6419    pub blend_enable: bool,
6420    pub src_color_blend_factor: BlendFactor,
6421    pub dst_color_blend_factor: BlendFactor,
6422    pub color_blend_op: BlendOp,
6423    pub src_alpha_blend_factor: BlendFactor,
6424    pub dst_alpha_blend_factor: BlendFactor,
6425    pub alpha_blend_op: BlendOp,
6426    pub color_write_mask: ColorComponentFlags,
6427}
6428
6429impl<'a> From<&'a PipelineColorBlendAttachmentState> for vks::core::VkPipelineColorBlendAttachmentState {
6430    fn from(state: &'a PipelineColorBlendAttachmentState) -> Self {
6431        vks::core::VkPipelineColorBlendAttachmentState {
6432            blendEnable: utils::to_vk_bool(state.blend_enable),
6433            srcColorBlendFactor: state.src_color_blend_factor.into(),
6434            dstColorBlendFactor: state.dst_color_blend_factor.into(),
6435            colorBlendOp: state.color_blend_op.into(),
6436            srcAlphaBlendFactor: state.src_alpha_blend_factor.into(),
6437            dstAlphaBlendFactor: state.dst_alpha_blend_factor.into(),
6438            alphaBlendOp: state.alpha_blend_op.into(),
6439            colorWriteMask: state.color_write_mask.bits(),
6440        }
6441    }
6442}
6443
6444gen_chain_struct! {
6445    name: PipelineColorBlendStateCreateInfoChain [PipelineColorBlendStateCreateInfoChainWrapper],
6446    query: PipelineColorBlendStateCreateInfoChainQuery [PipelineColorBlendStateCreateInfoChainQueryWrapper],
6447    vks: vks::core::VkPipelineColorBlendStateCreateInfo,
6448    input: true,
6449    output: false,
6450}
6451
6452/// See [`VkPipelineColorBlendStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineColorBlendStateCreateInfo)
6453#[derive(Debug, Clone, PartialEq)]
6454pub struct PipelineColorBlendStateCreateInfo {
6455    pub flags: PipelineColorBlendStateCreateFlags,
6456    pub logic_op_enable: bool,
6457    pub logic_op: LogicOp,
6458    pub attachments: Vec<PipelineColorBlendAttachmentState>,
6459    pub blend_constants: [f32; 4],
6460    pub chain: Option<PipelineColorBlendStateCreateInfoChain>,
6461}
6462
6463#[derive(Debug)]
6464struct VkPipelineColorBlendStateCreateInfoWrapper {
6465    pub vks_struct: vks::core::VkPipelineColorBlendStateCreateInfo,
6466    attachments: Vec<vks::core::VkPipelineColorBlendAttachmentState>,
6467    chain: Option<PipelineColorBlendStateCreateInfoChainWrapper>,
6468}
6469
6470impl VkPipelineColorBlendStateCreateInfoWrapper {
6471    pub fn new(create_info: &PipelineColorBlendStateCreateInfo, with_chain: bool) -> Self {
6472        let attachments: Vec<_> = create_info.attachments.iter().map(From::from).collect();
6473        let attachments_ptr = if !attachments.is_empty() {
6474            attachments.as_ptr()
6475        }
6476        else {
6477            ptr::null()
6478        };
6479
6480        let (pnext, chain) = PipelineColorBlendStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6481
6482        VkPipelineColorBlendStateCreateInfoWrapper {
6483            vks_struct: vks::core::VkPipelineColorBlendStateCreateInfo {
6484                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
6485                pNext: pnext,
6486                flags: create_info.flags.bits(),
6487                logicOpEnable: utils::to_vk_bool(create_info.logic_op_enable),
6488                logicOp: create_info.logic_op.into(),
6489                attachmentCount: attachments.len() as u32,
6490                pAttachments: attachments_ptr,
6491                blendConstants: create_info.blend_constants,
6492            },
6493            attachments: attachments,
6494            chain: chain,
6495        }
6496    }
6497}
6498
6499gen_chain_struct! {
6500    name: PipelineDynamicStateCreateInfoChain [PipelineDynamicStateCreateInfoChainWrapper],
6501    query: PipelineDynamicStateCreateInfoChainQuery [PipelineDynamicStateCreateInfoChainQueryWrapper],
6502    vks: vks::core::VkPipelineDynamicStateCreateInfo,
6503    input: true,
6504    output: false,
6505}
6506
6507/// See [`VkPipelineDynamicStateCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineDynamicStateCreateInfo)
6508#[derive(Debug, Clone, PartialEq)]
6509pub struct PipelineDynamicStateCreateInfo {
6510    pub flags: PipelineDynamicStateCreateFlags,
6511    pub dynamic_states: Vec<DynamicState>,
6512    pub chain: Option<PipelineDynamicStateCreateInfoChain>,
6513}
6514
6515#[derive(Debug)]
6516struct VkPipelineDynamicStateCreateInfoWrapper {
6517    pub vks_struct: vks::core::VkPipelineDynamicStateCreateInfo,
6518    dynamic_states: Vec<vks::core::VkDynamicState>,
6519    chain: Option<PipelineDynamicStateCreateInfoChainWrapper>,
6520}
6521
6522impl VkPipelineDynamicStateCreateInfoWrapper {
6523    pub fn new(create_info: &PipelineDynamicStateCreateInfo, with_chain: bool) -> Self {
6524        let dynamic_states: Vec<_> = create_info.dynamic_states
6525            .iter()
6526            .cloned()
6527            .map(From::from)
6528            .collect();
6529
6530        let (pnext, chain) = PipelineDynamicStateCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6531
6532        VkPipelineDynamicStateCreateInfoWrapper {
6533            vks_struct: vks::core::VkPipelineDynamicStateCreateInfo {
6534                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
6535                pNext: pnext,
6536                flags: create_info.flags.bits(),
6537                dynamicStateCount: dynamic_states.len() as u32,
6538                pDynamicStates: dynamic_states.as_ptr(),
6539            },
6540            dynamic_states: dynamic_states,
6541            chain: chain,
6542        }
6543    }
6544}
6545
6546gen_chain_struct! {
6547    name: GraphicsPipelineCreateInfoChain [GraphicsPipelineCreateInfoChainWrapper],
6548    query: GraphicsPipelineCreateInfoChainQuery [GraphicsPipelineCreateInfoChainQueryWrapper],
6549    vks: vks::core::VkGraphicsPipelineCreateInfo,
6550    input: true,
6551    output: false,
6552}
6553
6554/// See [`VkGraphicsPipelineCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkGraphicsPipelineCreateInfo)
6555#[derive(Debug, Clone, PartialEq)]
6556pub struct GraphicsPipelineCreateInfo {
6557    pub flags: PipelineCreateFlags,
6558    pub stages: Vec<PipelineShaderStageCreateInfo>,
6559    pub vertex_input_state: PipelineVertexInputStateCreateInfo,
6560    pub input_assembly_state: PipelineInputAssemblyStateCreateInfo,
6561    pub tessellation_state: Option<PipelineTessellationStateCreateInfo>,
6562    pub viewport_state: Option<PipelineViewportStateCreateInfo>,
6563    pub rasterization_state: PipelineRasterizationStateCreateInfo,
6564    pub multisample_state: Option<PipelineMultisampleStateCreateInfo>,
6565    pub depth_stencil_state: Option<PipelineDepthStencilStateCreateInfo>,
6566    pub color_blend_state: Option<PipelineColorBlendStateCreateInfo>,
6567    pub dynamic_state: Option<PipelineDynamicStateCreateInfo>,
6568    pub layout: PipelineLayout,
6569    pub render_pass: RenderPass,
6570    pub subpass: u32,
6571    pub base_pipeline: Option<Pipeline>,
6572    pub base_pipeline_index: Option<u32>,
6573    pub chain: Option<GraphicsPipelineCreateInfoChain>,
6574}
6575
6576#[derive(Debug)]
6577struct VkGraphicsPipelineCreateInfoWrapper {
6578    pub vks_struct: vks::core::VkGraphicsPipelineCreateInfo,
6579    stages: Vec<VkPipelineShaderStageCreateInfoWrapper>,
6580    vk_stages: Vec<vks::core::VkPipelineShaderStageCreateInfo>,
6581    vertex_input_state: Box<VkPipelineVertexInputStateCreateInfoWrapper>,
6582    input_assembly_state: Box<VkPipelineInputAssemblyStateCreateInfoWrapper>,
6583    tessellation_state: Option<Box<VkPipelineTessellationStateCreateInfoWrapper>>,
6584    viewport_state: Option<Box<VkPipelineViewportStateCreateInfoWrapper>>,
6585    rasterization_state: Box<VkPipelineRasterizationStateCreateInfoWrapper>,
6586    multisample_state: Option<Box<VkPipelineMultisampleStateCreateInfoWrapper>>,
6587    depth_stencil_state: Option<Box<VkPipelineDepthStencilStateCreateInfoWrapper>>,
6588    color_blend_state: Option<Box<VkPipelineColorBlendStateCreateInfoWrapper>>,
6589    dynamic_state: Option<Box<VkPipelineDynamicStateCreateInfoWrapper>>,
6590    layout: PipelineLayout,
6591    render_pass: RenderPass,
6592    base_pipeline: Option<Pipeline>,
6593    chain: Option<GraphicsPipelineCreateInfoChainWrapper>,
6594}
6595
6596impl VkGraphicsPipelineCreateInfoWrapper {
6597    pub fn new(create_info: &GraphicsPipelineCreateInfo, with_chain: bool) -> Self {
6598        let stages: Vec<_> = create_info.stages.iter().map(|c| VkPipelineShaderStageCreateInfoWrapper::new(c, true)).collect();
6599        let vk_stages: Vec<_> = stages.iter().map(|s| s.vks_struct).collect();
6600        let vertex_input_state: Box<_> = Box::new(VkPipelineVertexInputStateCreateInfoWrapper::new(&create_info.vertex_input_state, true));
6601        let input_assembly_state: Box<_> = Box::new(VkPipelineInputAssemblyStateCreateInfoWrapper::new(&create_info.input_assembly_state, true));
6602
6603        let (tessellation_state_ptr, tessellation_state) = match create_info.tessellation_state {
6604            Some(ref tessellation_state) => {
6605                let tessellation_state: Box<_> = Box::new(VkPipelineTessellationStateCreateInfoWrapper::new(tessellation_state, true));
6606                (&tessellation_state.vks_struct as *const _, Some(tessellation_state))
6607            }
6608
6609            None => (ptr::null(), None),
6610        };
6611
6612        let (viewport_state_ptr, viewport_state) = match create_info.viewport_state {
6613            Some(ref viewport_state) => {
6614                let viewport_state: Box<_> = Box::new(VkPipelineViewportStateCreateInfoWrapper::new(viewport_state, true));
6615                (&viewport_state.vks_struct as *const _, Some(viewport_state))
6616            }
6617
6618            None => (ptr::null(), None),
6619        };
6620
6621        let rasterization_state: Box<_> = Box::new(VkPipelineRasterizationStateCreateInfoWrapper::new(&create_info.rasterization_state, true));
6622
6623        let (multisample_state_ptr, multisample_state) = match create_info.multisample_state {
6624            Some(ref multisample_state) => {
6625                let multisample_state: Box<_> = Box::new(VkPipelineMultisampleStateCreateInfoWrapper::new(multisample_state, true));
6626                (&multisample_state.vks_struct as *const _, Some(multisample_state))
6627            }
6628
6629            None => (ptr::null(), None),
6630        };
6631
6632        let (depth_stencil_state_ptr, depth_stencil_state) = match create_info.depth_stencil_state {
6633            Some(ref depth_stencil_state) => {
6634                let depth_stencil_state: Box<_> = Box::new(VkPipelineDepthStencilStateCreateInfoWrapper::new(depth_stencil_state, true));
6635                (&depth_stencil_state.vks_struct as *const _, Some(depth_stencil_state))
6636            }
6637
6638            None => (ptr::null(), None),
6639        };
6640
6641        let (color_blend_state_ptr, color_blend_state) = match create_info.color_blend_state {
6642            Some(ref color_blend_state) => {
6643                let color_blend_state: Box<_> = Box::new(VkPipelineColorBlendStateCreateInfoWrapper::new(color_blend_state, true));
6644                (&color_blend_state.vks_struct as *const _, Some(color_blend_state))
6645            }
6646
6647            None => (ptr::null(), None),
6648        };
6649
6650        let (dynamic_state_ptr, dynamic_state) = match create_info.dynamic_state {
6651            Some(ref dynamic_state) => {
6652                let dynamic_state: Box<_> = Box::new(VkPipelineDynamicStateCreateInfoWrapper::new(dynamic_state, true));
6653                (&dynamic_state.vks_struct as *const _, Some(dynamic_state))
6654            }
6655
6656            None => (ptr::null(), None),
6657        };
6658
6659        let (base_pipeline_handle, base_pipeline) = match create_info.base_pipeline {
6660            Some(ref base_pipeline) => (base_pipeline.handle(), Some(base_pipeline.clone())),
6661            None => (Default::default(), None),
6662        };
6663
6664        let base_pipeline_index = match create_info.base_pipeline_index {
6665            Some(base_pipeline_index) => base_pipeline_index as i32,
6666            None => -1,
6667        };
6668
6669        let (pnext, chain) = GraphicsPipelineCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6670
6671        VkGraphicsPipelineCreateInfoWrapper {
6672            vks_struct: vks::core::VkGraphicsPipelineCreateInfo {
6673                sType: vks::core::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
6674                pNext: pnext,
6675                flags: create_info.flags.bits(),
6676                stageCount: stages.len() as u32,
6677                pStages: vk_stages.as_ptr(),
6678                pVertexInputState: &vertex_input_state.vks_struct,
6679                pInputAssemblyState: &input_assembly_state.vks_struct,
6680                pTessellationState: tessellation_state_ptr,
6681                pViewportState: viewport_state_ptr,
6682                pRasterizationState: &rasterization_state.vks_struct,
6683                pMultisampleState: multisample_state_ptr,
6684                pDepthStencilState: depth_stencil_state_ptr,
6685                pColorBlendState: color_blend_state_ptr,
6686                pDynamicState: dynamic_state_ptr,
6687                layout: create_info.layout.handle(),
6688                renderPass: create_info.render_pass.handle(),
6689                subpass: create_info.subpass,
6690                basePipelineHandle: base_pipeline_handle,
6691                basePipelineIndex: base_pipeline_index,
6692            },
6693            stages: stages,
6694            vk_stages: vk_stages,
6695            vertex_input_state: vertex_input_state,
6696            input_assembly_state: input_assembly_state,
6697            tessellation_state: tessellation_state,
6698            viewport_state: viewport_state,
6699            rasterization_state: rasterization_state,
6700            multisample_state: multisample_state,
6701            depth_stencil_state: depth_stencil_state,
6702            color_blend_state: color_blend_state,
6703            dynamic_state: dynamic_state,
6704            layout: create_info.layout.clone(),
6705            render_pass: create_info.render_pass.clone(),
6706            base_pipeline: base_pipeline,
6707            chain: chain,
6708        }
6709    }
6710}
6711
6712gen_chain_struct! {
6713    name: ComputePipelineCreateInfoChain [ComputePipelineCreateInfoChainWrapper],
6714    query: ComputePipelineCreateInfoChainQuery [ComputePipelineCreateInfoChainQueryWrapper],
6715    vks: vks::core::VkComputePipelineCreateInfo,
6716    input: true,
6717    output: false,
6718}
6719
6720/// See [`VkComputePipelineCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkComputePipelineCreateInfo)
6721#[derive(Debug, Clone, PartialEq)]
6722pub struct ComputePipelineCreateInfo {
6723    pub flags: PipelineCreateFlags,
6724    pub stage: PipelineShaderStageCreateInfo,
6725    pub layout: PipelineLayout,
6726    pub base_pipeline: Option<Pipeline>,
6727    pub base_pipeline_index: Option<u32>,
6728    pub chain: Option<ComputePipelineCreateInfoChain>,
6729}
6730
6731#[derive(Debug)]
6732struct VkComputePipelineCreateInfoWrapper {
6733    pub vks_struct: vks::core::VkComputePipelineCreateInfo,
6734    stage: VkPipelineShaderStageCreateInfoWrapper,
6735    layout: PipelineLayout,
6736    base_pipeline: Option<Pipeline>,
6737    chain: Option<ComputePipelineCreateInfoChainWrapper>,
6738}
6739
6740impl VkComputePipelineCreateInfoWrapper {
6741    pub fn new(create_info: &ComputePipelineCreateInfo, with_chain: bool) -> Self {
6742        let stage = VkPipelineShaderStageCreateInfoWrapper::new(&create_info.stage, true);
6743
6744        let (base_pipeline_handle, base_pipeline) = match create_info.base_pipeline {
6745            Some(ref base_pipeline) => (base_pipeline.handle(), Some(base_pipeline.clone())),
6746            None => (Default::default(), None),
6747        };
6748
6749        let base_pipeline_index = match create_info.base_pipeline_index {
6750            Some(base_pipeline_index) => base_pipeline_index as i32,
6751            None => -1,
6752        };
6753
6754        let (pnext, chain) = ComputePipelineCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6755
6756        VkComputePipelineCreateInfoWrapper {
6757            vks_struct: vks::core::VkComputePipelineCreateInfo {
6758                sType: vks::core::VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
6759                pNext: pnext,
6760                flags: create_info.flags.bits(),
6761                stage: stage.vks_struct,
6762                layout: create_info.layout.handle(),
6763                basePipelineHandle: base_pipeline_handle,
6764                basePipelineIndex: base_pipeline_index,
6765            },
6766            stage: stage,
6767            layout: create_info.layout.clone(),
6768            base_pipeline: base_pipeline,
6769            chain: chain,
6770        }
6771    }
6772}
6773
6774/// See [`VkPushConstantRange`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPushConstantRange)
6775#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6776pub struct PushConstantRange {
6777    pub stage_flags: ShaderStageFlags,
6778    pub offset: u32,
6779    pub size: u32,
6780}
6781
6782impl<'a> From<&'a PushConstantRange> for vks::core::VkPushConstantRange {
6783    fn from(range: &'a PushConstantRange) -> Self {
6784        vks::core::VkPushConstantRange {
6785            stageFlags: range.stage_flags.bits(),
6786            offset: range.offset,
6787            size: range.size,
6788        }
6789    }
6790}
6791
6792gen_chain_struct! {
6793    name: PipelineLayoutCreateInfoChain [PipelineLayoutCreateInfoChainWrapper],
6794    query: PipelineLayoutCreateInfoChainQuery [PipelineLayoutCreateInfoChainQueryWrapper],
6795    vks: vks::core::VkPipelineLayoutCreateInfo,
6796    input: true,
6797    output: false,
6798}
6799
6800/// See [`VkPipelineLayoutCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkPipelineLayoutCreateInfo)
6801#[derive(Debug, Clone, PartialEq)]
6802pub struct PipelineLayoutCreateInfo {
6803    pub flags: PipelineLayoutCreateFlags,
6804    pub set_layouts: Vec<DescriptorSetLayout>,
6805    pub push_constant_ranges: Vec<PushConstantRange>,
6806    pub chain: Option<PipelineLayoutCreateInfoChain>,
6807}
6808
6809#[derive(Debug)]
6810struct VkPipelineLayoutCreateInfoWrapper {
6811    pub vks_struct: vks::core::VkPipelineLayoutCreateInfo,
6812    set_layouts: Vec<DescriptorSetLayout>,
6813    vk_set_layouts: Vec<vks::core::VkDescriptorSetLayout>,
6814    push_constant_ranges: Vec<vks::core::VkPushConstantRange>,
6815    chain: Option<PipelineLayoutCreateInfoChainWrapper>,
6816}
6817
6818impl VkPipelineLayoutCreateInfoWrapper {
6819    pub fn new(create_info: &PipelineLayoutCreateInfo, with_chain: bool) -> Self {
6820        let set_layouts = create_info.set_layouts.clone();
6821        let vk_set_layouts: Vec<_> = set_layouts.iter().map(DescriptorSetLayout::handle).collect();
6822        let vk_set_layouts_ptr = if !vk_set_layouts.is_empty() {
6823            vk_set_layouts.as_ptr()
6824        }
6825        else {
6826            ptr::null()
6827        };
6828
6829        let push_constant_ranges: Vec<_> = create_info.push_constant_ranges.iter().map(From::from).collect();
6830        let push_constant_ranges_ptr = if !push_constant_ranges.is_empty() {
6831            push_constant_ranges.as_ptr()
6832        }
6833        else {
6834            ptr::null()
6835        };
6836
6837        let (pnext, chain) = PipelineLayoutCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6838
6839        VkPipelineLayoutCreateInfoWrapper {
6840            vks_struct: vks::core::VkPipelineLayoutCreateInfo {
6841                sType: vks::core::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
6842                pNext: pnext,
6843                flags: create_info.flags.bits(),
6844                setLayoutCount: set_layouts.len() as u32,
6845                pSetLayouts: vk_set_layouts_ptr,
6846                pushConstantRangeCount: push_constant_ranges.len() as u32,
6847                pPushConstantRanges: push_constant_ranges_ptr,
6848            },
6849            set_layouts: set_layouts,
6850            vk_set_layouts: vk_set_layouts,
6851            push_constant_ranges: push_constant_ranges,
6852            chain: chain,
6853        }
6854    }
6855}
6856
6857gen_chain_struct! {
6858    name: SamplerCreateInfoChain [SamplerCreateInfoChainWrapper],
6859    query: SamplerCreateInfoChainQuery [SamplerCreateInfoChainQueryWrapper],
6860    vks: vks::core::VkSamplerCreateInfo,
6861    input: true,
6862    output: false,
6863}
6864
6865/// See [`VkSamplerCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSamplerCreateInfo)
6866#[derive(Debug, Clone, PartialEq)]
6867pub struct SamplerCreateInfo {
6868    pub flags: SamplerCreateFlags,
6869    pub mag_filter: Filter,
6870    pub min_filter: Filter,
6871    pub mipmap_mode: SamplerMipmapMode,
6872    pub address_mode_u: SamplerAddressMode,
6873    pub address_mode_v: SamplerAddressMode,
6874    pub address_mode_w: SamplerAddressMode,
6875    pub mip_lod_bias: f32,
6876    pub anisotropy_enable: bool,
6877    pub max_anisotropy: f32,
6878    pub compare_enable: bool,
6879    pub compare_op: CompareOp,
6880    pub min_lod: f32,
6881    pub max_lod: f32,
6882    pub border_color: BorderColor,
6883    pub unnormalized_coordinates: bool,
6884    pub chain: Option<SamplerCreateInfoChain>,
6885}
6886
6887#[derive(Debug)]
6888struct VkSamplerCreateInfoWrapper {
6889    pub vks_struct: vks::core::VkSamplerCreateInfo,
6890    chain: Option<SamplerCreateInfoChainWrapper>,
6891}
6892
6893impl VkSamplerCreateInfoWrapper {
6894    pub fn new(create_info: &SamplerCreateInfo, with_chain: bool) -> Self {
6895        let (pnext, chain) = SamplerCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
6896
6897        VkSamplerCreateInfoWrapper {
6898            vks_struct: vks::core::VkSamplerCreateInfo {
6899                sType: vks::core::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
6900                pNext: pnext,
6901                flags: create_info.flags.bits(),
6902                magFilter: create_info.mag_filter.into(),
6903                minFilter: create_info.min_filter.into(),
6904                mipmapMode: create_info.mipmap_mode.into(),
6905                addressModeU: create_info.address_mode_u.into(),
6906                addressModeV: create_info.address_mode_v.into(),
6907                addressModeW: create_info.address_mode_w.into(),
6908                mipLodBias: create_info.mip_lod_bias,
6909                anisotropyEnable: utils::to_vk_bool(create_info.anisotropy_enable),
6910                maxAnisotropy: create_info.max_anisotropy,
6911                compareEnable: utils::to_vk_bool(create_info.compare_enable),
6912                compareOp: create_info.compare_op.into(),
6913                minLod: create_info.min_lod,
6914                maxLod: create_info.max_lod,
6915                borderColor: create_info.border_color.into(),
6916                unnormalizedCoordinates: utils::to_vk_bool(create_info.unnormalized_coordinates),
6917            },
6918            chain: chain,
6919        }
6920    }
6921}
6922
6923/// See [`VkDescriptorSetLayoutBinding`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorSetLayoutBinding)
6924#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6925pub struct DescriptorSetLayoutBinding {
6926    pub binding: u32,
6927    pub descriptor_type: DescriptorType,
6928    pub descriptor_count: u32,
6929    pub stage_flags: ShaderStageFlags,
6930    pub immutable_samplers: Vec<Sampler>,
6931}
6932
6933#[derive(Debug)]
6934struct VkDescriptorSetLayoutBindingWrapper {
6935    pub vks_struct: vks::core::VkDescriptorSetLayoutBinding,
6936    immutable_samplers: Vec<Sampler>,
6937    immutable_vk_samplers: Vec<vks::core::VkSampler>,
6938}
6939
6940impl<'a> From<&'a DescriptorSetLayoutBinding> for VkDescriptorSetLayoutBindingWrapper {
6941    fn from(binding: &'a DescriptorSetLayoutBinding) -> Self {
6942        let immutable_samplers = binding.immutable_samplers.clone();
6943        let immutable_vk_samplers: Vec<_> = immutable_samplers.iter().map(Sampler::handle).collect();
6944        let immutable_vk_samplers_ptr = if !immutable_vk_samplers.is_empty() {
6945            immutable_vk_samplers.as_ptr()
6946        }
6947        else {
6948            ptr::null()
6949        };
6950
6951        VkDescriptorSetLayoutBindingWrapper {
6952            vks_struct: vks::core::VkDescriptorSetLayoutBinding {
6953                binding: binding.binding,
6954                descriptorType: binding.descriptor_type.into(),
6955                descriptorCount: binding.descriptor_count,
6956                stageFlags: binding.stage_flags.bits(),
6957                pImmutableSamplers: immutable_vk_samplers_ptr,
6958            },
6959            immutable_samplers: immutable_samplers,
6960            immutable_vk_samplers: immutable_vk_samplers,
6961        }
6962    }
6963}
6964
6965gen_chain_struct! {
6966    name: DescriptorSetLayoutCreateInfoChain [DescriptorSetLayoutCreateInfoChainWrapper],
6967    query: DescriptorSetLayoutCreateInfoChainQuery [DescriptorSetLayoutCreateInfoChainQueryWrapper],
6968    vks: vks::core::VkDescriptorSetLayoutCreateInfo,
6969    input: true,
6970    output: false,
6971}
6972
6973/// See [`VkDescriptorSetLayoutCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorSetLayoutCreateInfo)
6974#[derive(Debug, Clone, PartialEq)]
6975pub struct DescriptorSetLayoutCreateInfo {
6976    pub flags: DescriptorSetLayoutCreateFlags,
6977    pub bindings: Vec<DescriptorSetLayoutBinding>,
6978    pub chain: Option<DescriptorSetLayoutCreateInfoChain>,
6979}
6980
6981#[derive(Debug)]
6982struct VkDescriptorSetLayoutCreateInfoWrapper {
6983    pub vks_struct: vks::core::VkDescriptorSetLayoutCreateInfo,
6984    bindings: Vec<VkDescriptorSetLayoutBindingWrapper>,
6985    vk_bindings: Vec<vks::core::VkDescriptorSetLayoutBinding>,
6986    chain: Option<DescriptorSetLayoutCreateInfoChainWrapper>,
6987}
6988
6989impl VkDescriptorSetLayoutCreateInfoWrapper {
6990    pub fn new(create_info: &DescriptorSetLayoutCreateInfo, with_chain: bool) -> Self {
6991        let bindings: Vec<VkDescriptorSetLayoutBindingWrapper> = create_info.bindings.iter().map(From::from).collect();
6992        let vk_bindings: Vec<_> = bindings.iter().map(|b| b.vks_struct).collect();
6993        let vk_bindings_ptr = if !vk_bindings.is_empty() {
6994            vk_bindings.as_ptr()
6995        }
6996        else {
6997            ptr::null()
6998        };
6999
7000        let (pnext, chain) = DescriptorSetLayoutCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
7001
7002        VkDescriptorSetLayoutCreateInfoWrapper {
7003            vks_struct: vks::core::VkDescriptorSetLayoutCreateInfo {
7004                sType: vks::core::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
7005                pNext: pnext,
7006                flags: create_info.flags.bits(),
7007                bindingCount: bindings.len() as u32,
7008                pBindings: vk_bindings_ptr,
7009            },
7010            bindings: bindings,
7011            vk_bindings: vk_bindings,
7012            chain: chain,
7013        }
7014    }
7015}
7016
7017/// See [`VkDescriptorPoolSize`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorPoolSize)
7018#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7019pub struct DescriptorPoolSize {
7020    pub descriptor_type: DescriptorType,
7021    pub descriptor_count: u32,
7022}
7023
7024impl<'a> From<&'a DescriptorPoolSize> for vks::core::VkDescriptorPoolSize {
7025    fn from(size: &'a DescriptorPoolSize) -> Self {
7026        vks::core::VkDescriptorPoolSize {
7027            type_: size.descriptor_type.into(),
7028            descriptorCount: size.descriptor_count,
7029        }
7030    }
7031}
7032
7033gen_chain_struct! {
7034    name: DescriptorPoolCreateInfoChain [DescriptorPoolCreateInfoChainWrapper],
7035    query: DescriptorPoolCreateInfoChainQuery [DescriptorPoolCreateInfoChainQueryWrapper],
7036    vks: vks::core::VkDescriptorPoolCreateInfo,
7037    input: true,
7038    output: false,
7039}
7040
7041/// See [`VkDescriptorPoolCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorPoolCreateInfo)
7042#[derive(Debug, Clone, PartialEq)]
7043pub struct DescriptorPoolCreateInfo {
7044    pub flags: DescriptorPoolCreateFlags,
7045    pub max_sets: u32,
7046    pub pool_sizes: Vec<DescriptorPoolSize>,
7047    pub chain: Option<DescriptorPoolCreateInfoChain>,
7048}
7049
7050#[derive(Debug)]
7051struct VkDescriptorPoolCreateInfoWrapper {
7052    pub vks_struct: vks::core::VkDescriptorPoolCreateInfo,
7053    pool_sizes: Vec<vks::core::VkDescriptorPoolSize>,
7054    chain: Option<DescriptorPoolCreateInfoChainWrapper>,
7055}
7056
7057impl VkDescriptorPoolCreateInfoWrapper {
7058    pub fn new(create_info: &DescriptorPoolCreateInfo, with_chain: bool) -> Self {
7059        let pool_sizes: Vec<_> = create_info.pool_sizes
7060            .iter()
7061            .map(From::from)
7062            .collect();
7063
7064        let (pnext, chain) = DescriptorPoolCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
7065
7066        VkDescriptorPoolCreateInfoWrapper {
7067            vks_struct: vks::core::VkDescriptorPoolCreateInfo {
7068                sType: vks::core::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
7069                pNext: pnext,
7070                flags: create_info.flags.bits(),
7071                maxSets: create_info.max_sets,
7072                poolSizeCount: pool_sizes.len() as u32,
7073                pPoolSizes: pool_sizes.as_ptr(),
7074            },
7075            pool_sizes: pool_sizes,
7076            chain: chain,
7077        }
7078    }
7079}
7080
7081gen_chain_struct! {
7082    name: DescriptorSetAllocateInfoChain [DescriptorSetAllocateInfoChainWrapper],
7083    query: DescriptorSetAllocateInfoChainQuery [DescriptorSetAllocateInfoChainQueryWrapper],
7084    vks: vks::core::VkDescriptorSetAllocateInfo,
7085    input: true,
7086    output: false,
7087}
7088
7089/// See [`VkDescriptorSetAllocateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorSetAllocateInfo)
7090#[derive(Debug, Clone, PartialEq)]
7091pub struct DescriptorSetAllocateInfo {
7092    pub descriptor_pool: DescriptorPool,
7093    pub set_layouts: Vec<DescriptorSetLayout>,
7094    pub chain: Option<DescriptorSetAllocateInfoChain>,
7095}
7096
7097#[derive(Debug)]
7098struct VkDescriptorSetAllocateInfoWrapper {
7099    pub vks_struct: vks::core::VkDescriptorSetAllocateInfo,
7100    descriptor_pool: DescriptorPool,
7101    set_layouts: Vec<DescriptorSetLayout>,
7102    vk_set_layouts: Vec<vks::core::VkDescriptorSetLayout>,
7103    chain: Option<DescriptorSetAllocateInfoChainWrapper>,
7104}
7105
7106impl VkDescriptorSetAllocateInfoWrapper {
7107    pub fn new(allocate_info: &DescriptorSetAllocateInfo, with_chain: bool) -> Self {
7108        let vk_set_layouts: Vec<_> = allocate_info.set_layouts.iter().map(DescriptorSetLayout::handle).collect();
7109        let (pnext, chain) = DescriptorSetAllocateInfoChainWrapper::new_optional(&allocate_info.chain, with_chain);
7110
7111        VkDescriptorSetAllocateInfoWrapper {
7112            vks_struct: vks::core::VkDescriptorSetAllocateInfo {
7113                sType: vks::core::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
7114                pNext: pnext,
7115                descriptorPool: allocate_info.descriptor_pool.handle(),
7116                descriptorSetCount: vk_set_layouts.len() as u32,
7117                pSetLayouts: vk_set_layouts.as_ptr(),
7118            },
7119            descriptor_pool: allocate_info.descriptor_pool.clone(),
7120            set_layouts: allocate_info.set_layouts.clone(),
7121            vk_set_layouts: vk_set_layouts,
7122            chain: chain,
7123        }
7124    }
7125}
7126
7127/// See [`VkDescriptorImageInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorImageInfo)
7128#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7129pub struct DescriptorImageInfo {
7130    pub sampler: Option<Sampler>,
7131    pub image_view: Option<ImageView>,
7132    pub image_layout: ImageLayout,
7133}
7134
7135#[derive(Debug)]
7136struct VkDescriptorImageInfoWrapper {
7137    pub vks_struct: vks::core::VkDescriptorImageInfo,
7138    sampler: Option<Sampler>,
7139    image_view: Option<ImageView>,
7140}
7141
7142impl<'a> From<&'a DescriptorImageInfo> for VkDescriptorImageInfoWrapper {
7143    fn from(info: &'a DescriptorImageInfo) -> Self {
7144        let (vk_sampler, sampler) = match info.sampler {
7145            Some(ref sampler) => (sampler.handle(), Some(sampler.clone())),
7146            None => (Default::default(), None),
7147        };
7148
7149        let (vk_image_view, image_view) = match info.image_view {
7150            Some(ref image_view) => (image_view.handle(), Some(image_view.clone())),
7151            None => (Default::default(), None),
7152        };
7153
7154        VkDescriptorImageInfoWrapper {
7155            vks_struct: vks::core::VkDescriptorImageInfo {
7156                sampler: vk_sampler,
7157                imageView: vk_image_view,
7158                imageLayout: info.image_layout.into(),
7159            },
7160            sampler: sampler,
7161            image_view: image_view,
7162        }
7163    }
7164}
7165
7166/// See [`VkDescriptorBufferInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDescriptorBufferInfo)
7167#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7168pub struct DescriptorBufferInfo {
7169    pub buffer: Buffer,
7170    pub offset: u64,
7171    pub range: OptionalDeviceSize,
7172}
7173
7174#[derive(Debug)]
7175struct VkDescriptorBufferInfoWrapper {
7176    pub vks_struct: vks::core::VkDescriptorBufferInfo,
7177    buffer: Buffer,
7178}
7179
7180impl<'a> From<&'a DescriptorBufferInfo> for VkDescriptorBufferInfoWrapper {
7181    fn from(info: &'a DescriptorBufferInfo) -> Self {
7182        VkDescriptorBufferInfoWrapper {
7183            vks_struct: vks::core::VkDescriptorBufferInfo {
7184                buffer: info.buffer.handle(),
7185                offset: info.offset,
7186                range: info.range.into(),
7187            },
7188            buffer: info.buffer.clone(),
7189        }
7190    }
7191}
7192
7193gen_chain_struct! {
7194    name: WriteDescriptorSetChain [WriteDescriptorSetChainWrapper],
7195    query: WriteDescriptorSetChainQuery [WriteDescriptorSetChainQueryWrapper],
7196    vks: vks::core::VkWriteDescriptorSet,
7197    input: true,
7198    output: false,
7199}
7200
7201/// See [`VkWriteDescriptorSet`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkWriteDescriptorSet)
7202#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7203pub enum WriteDescriptorSetElements {
7204    ImageInfo(Vec<DescriptorImageInfo>),
7205    BufferInfo(Vec<DescriptorBufferInfo>),
7206    TexelBufferView(Vec<BufferView>),
7207}
7208
7209/// See [`VkWriteDescriptorSet`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkWriteDescriptorSet)
7210#[derive(Debug, Clone, PartialEq)]
7211pub struct WriteDescriptorSet {
7212    pub dst_set: DescriptorSet,
7213    pub dst_binding: u32,
7214    pub dst_array_element: u32,
7215    pub descriptor_type: DescriptorType,
7216    pub elements: WriteDescriptorSetElements,
7217    pub chain: Option<WriteDescriptorSetChain>,
7218}
7219
7220#[derive(Debug)]
7221struct VkWriteDescriptorSetWrapper {
7222    pub vks_struct: vks::core::VkWriteDescriptorSet,
7223    dst_set: DescriptorSet,
7224    image_info: Vec<VkDescriptorImageInfoWrapper>,
7225    vk_image_info: Vec<vks::core::VkDescriptorImageInfo>,
7226    buffer_info: Vec<VkDescriptorBufferInfoWrapper>,
7227    vk_buffer_info: Vec<vks::core::VkDescriptorBufferInfo>,
7228    texel_buffer_view: Vec<BufferView>,
7229    vk_texel_buffer_view: Vec<vks::core::VkBufferView>,
7230    chain: Option<WriteDescriptorSetChainWrapper>,
7231}
7232
7233impl VkWriteDescriptorSetWrapper {
7234    pub fn new(write: &WriteDescriptorSet, with_chain: bool) -> Self {
7235        let (count,
7236             vk_image_info_ptr,
7237             vk_image_info,
7238             image_info,
7239             vk_buffer_info_ptr,
7240             vk_buffer_info,
7241             buffer_info,
7242             vk_texel_buffer_view_ptr,
7243             vk_texel_buffer_view,
7244             texel_buffer_view) = match write.elements {
7245            WriteDescriptorSetElements::ImageInfo(ref image_info) => {
7246                let image_info: Vec<VkDescriptorImageInfoWrapper> = image_info.iter().map(From::from).collect();
7247                let vk_image_info: Vec<_> = image_info.iter().map(|i| i.vks_struct).collect();
7248                (image_info.len() as u32, vk_image_info.as_ptr(), vk_image_info, image_info, ptr::null(), vec![], vec![], ptr::null(), vec![], vec![])
7249            },
7250
7251            WriteDescriptorSetElements::BufferInfo(ref buffer_info) => {
7252                let buffer_info: Vec<VkDescriptorBufferInfoWrapper> = buffer_info.iter().map(From::from).collect();
7253                let vk_buffer_info: Vec<_> = buffer_info.iter().map(|b| b.vks_struct).collect();
7254                (buffer_info.len() as u32, ptr::null(), vec![], vec![], vk_buffer_info.as_ptr(), vk_buffer_info, buffer_info, ptr::null(), vec![], vec![])
7255            },
7256
7257            WriteDescriptorSetElements::TexelBufferView(ref texel_buffer_view) => {
7258                let texel_buffer_view = texel_buffer_view.clone();
7259                let vk_texel_buffer_view: Vec<_> = texel_buffer_view.iter().map(BufferView::handle).collect();
7260                (texel_buffer_view.len() as u32, ptr::null(), vec![], vec![], ptr::null(), vec![], vec![], vk_texel_buffer_view.as_ptr(), vk_texel_buffer_view, texel_buffer_view)
7261            },
7262        };
7263
7264        let (pnext, chain) = WriteDescriptorSetChainWrapper::new_optional(&write.chain, with_chain);
7265
7266        VkWriteDescriptorSetWrapper {
7267            vks_struct: vks::core::VkWriteDescriptorSet {
7268                sType: vks::core::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
7269                pNext: pnext,
7270                dstSet: write.dst_set.handle(),
7271                dstBinding: write.dst_binding,
7272                dstArrayElement: write.dst_array_element,
7273                descriptorCount: count,
7274                descriptorType: write.descriptor_type.into(),
7275                pImageInfo: vk_image_info_ptr,
7276                pBufferInfo: vk_buffer_info_ptr,
7277                pTexelBufferView: vk_texel_buffer_view_ptr,
7278            },
7279            dst_set: write.dst_set.clone(),
7280            image_info: image_info,
7281            vk_image_info: vk_image_info,
7282            buffer_info: buffer_info,
7283            vk_buffer_info: vk_buffer_info,
7284            texel_buffer_view: texel_buffer_view,
7285            vk_texel_buffer_view: vk_texel_buffer_view,
7286            chain: chain,
7287        }
7288    }
7289}
7290
7291gen_chain_struct! {
7292    name: CopyDescriptorSetChain [CopyDescriptorSetChainWrapper],
7293    query: CopyDescriptorSetChainQuery [CopyDescriptorSetChainQueryWrapper],
7294    vks: vks::core::VkCopyDescriptorSet,
7295    input: true,
7296    output: false,
7297}
7298
7299/// See [`VkCopyDescriptorSet`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCopyDescriptorSet)
7300#[derive(Debug, Clone, PartialEq)]
7301pub struct CopyDescriptorSet {
7302    pub src_set: DescriptorSet,
7303    pub src_binding: u32,
7304    pub src_array_element: u32,
7305    pub dst_set: DescriptorSet,
7306    pub dst_binding: u32,
7307    pub dst_array_element: u32,
7308    pub descriptor_count: u32,
7309    pub chain: Option<CopyDescriptorSetChain>,
7310}
7311
7312#[derive(Debug)]
7313struct VkCopyDescriptorSetWrapper {
7314    pub vks_struct: vks::core::VkCopyDescriptorSet,
7315    src_set: DescriptorSet,
7316    dst_set: DescriptorSet,
7317    chain: Option<CopyDescriptorSetChainWrapper>,
7318}
7319
7320impl VkCopyDescriptorSetWrapper {
7321    pub fn new(copy: &CopyDescriptorSet, with_chain: bool) -> Self {
7322        let (pnext, chain) = CopyDescriptorSetChainWrapper::new_optional(&copy.chain, with_chain);
7323
7324        VkCopyDescriptorSetWrapper {
7325            vks_struct: vks::core::VkCopyDescriptorSet {
7326                sType: vks::core::VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
7327                pNext: pnext,
7328                srcSet: copy.src_set.handle(),
7329                srcBinding: copy.src_binding,
7330                srcArrayElement: copy.src_array_element,
7331                dstSet: copy.dst_set.handle(),
7332                dstBinding: copy.dst_binding,
7333                dstArrayElement: copy.dst_array_element,
7334                descriptorCount: copy.descriptor_count,
7335            },
7336            src_set: copy.src_set.clone(),
7337            dst_set: copy.dst_set.clone(),
7338            chain: chain,
7339        }
7340    }
7341}
7342
7343gen_chain_struct! {
7344    name: FramebufferCreateInfoChain [FramebufferCreateInfoChainWrapper],
7345    query: FramebufferCreateInfoChainQuery [FramebufferCreateInfoChainQueryWrapper],
7346    vks: vks::core::VkFramebufferCreateInfo,
7347    input: true,
7348    output: false,
7349}
7350
7351/// See [`VkFramebufferCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkFramebufferCreateInfo)
7352#[derive(Debug, Clone, PartialEq)]
7353pub struct FramebufferCreateInfo {
7354    pub flags: FramebufferCreateFlags,
7355    pub render_pass: RenderPass,
7356    pub attachments: Vec<ImageView>,
7357    pub width: u32,
7358    pub height: u32,
7359    pub layers: u32,
7360    pub chain: Option<FramebufferCreateInfoChain>,
7361}
7362
7363#[derive(Debug)]
7364struct VkFramebufferCreateInfoWrapper {
7365    pub vks_struct: vks::core::VkFramebufferCreateInfo,
7366    render_pass: RenderPass,
7367    attachments: Vec<ImageView>,
7368    vk_attachments: Vec<vks::core::VkImageView>,
7369    chain: Option<FramebufferCreateInfoChainWrapper>,
7370}
7371
7372impl VkFramebufferCreateInfoWrapper {
7373    pub fn new(create_info: &FramebufferCreateInfo, with_chain: bool) -> Self {
7374        let attachments = create_info.attachments.clone();
7375        let vk_attachments: Vec<_> = attachments.iter().map(ImageView::handle).collect();
7376        let vk_attachments_ptr = if !vk_attachments.is_empty() {
7377            vk_attachments.as_ptr()
7378        }
7379        else {
7380            ptr::null()
7381        };
7382
7383        let (pnext, chain) = FramebufferCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
7384
7385        VkFramebufferCreateInfoWrapper {
7386            vks_struct: vks::core::VkFramebufferCreateInfo {
7387                sType: vks::core::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
7388                pNext: pnext,
7389                flags: create_info.flags.bits(),
7390                renderPass: create_info.render_pass.handle(),
7391                attachmentCount: attachments.len() as u32,
7392                pAttachments: vk_attachments_ptr,
7393                width: create_info.width,
7394                height: create_info.height,
7395                layers: create_info.layers,
7396            },
7397            render_pass: create_info.render_pass.clone(),
7398            attachments: attachments,
7399            vk_attachments: vk_attachments,
7400            chain: chain,
7401        }
7402    }
7403}
7404
7405/// See [`VkAttachmentDescription`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkAttachmentDescription)
7406#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7407pub struct AttachmentDescription {
7408    pub flags: AttachmentDescriptionFlags,
7409    pub format: Format,
7410    pub samples: SampleCountFlagBits,
7411    pub load_op: AttachmentLoadOp,
7412    pub store_op: AttachmentStoreOp,
7413    pub stencil_load_op: AttachmentLoadOp,
7414    pub stencil_store_op: AttachmentStoreOp,
7415    pub initial_layout: ImageLayout,
7416    pub final_layout: ImageLayout,
7417}
7418
7419impl<'a> From<&'a AttachmentDescription> for vks::core::VkAttachmentDescription {
7420    fn from(description: &'a AttachmentDescription) -> Self {
7421        vks::core::VkAttachmentDescription {
7422            flags: description.flags.bits(),
7423            format: description.format.into(),
7424            samples: description.samples.bit(),
7425            loadOp: description.load_op.into(),
7426            storeOp: description.store_op.into(),
7427            stencilLoadOp: description.stencil_load_op.into(),
7428            stencilStoreOp: description.stencil_store_op.into(),
7429            initialLayout: description.initial_layout.into(),
7430            finalLayout: description.final_layout.into(),
7431        }
7432    }
7433}
7434
7435impl<'a> From<&'a vks::core::VkAttachmentDescription> for AttachmentDescription {
7436    fn from(description: &'a vks::core::VkAttachmentDescription) -> Self {
7437        AttachmentDescription {
7438            flags: AttachmentDescriptionFlags::from_bits_truncate(description.flags),
7439            format: description.format.into(),
7440            samples: SampleCountFlagBits::from_bits(description.samples).unwrap(),
7441            load_op: description.loadOp.into(),
7442            store_op: description.storeOp.into(),
7443            stencil_load_op: description.stencilLoadOp.into(),
7444            stencil_store_op: description.stencilStoreOp.into(),
7445            initial_layout: description.initialLayout.into(),
7446            final_layout: description.finalLayout.into(),
7447        }
7448    }
7449}
7450
7451/// See [`VkAttachmentReference`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkAttachmentReference)
7452#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7453pub struct AttachmentReference {
7454    pub attachment: AttachmentIndex,
7455    pub layout: ImageLayout,
7456}
7457
7458impl<'a> From<&'a AttachmentReference> for vks::core::VkAttachmentReference {
7459    fn from(reference: &'a AttachmentReference) -> Self {
7460        vks::core::VkAttachmentReference {
7461            attachment: reference.attachment.into(),
7462            layout: reference.layout.into(),
7463        }
7464    }
7465}
7466
7467impl<'a> From<&'a vks::core::VkAttachmentReference> for AttachmentReference {
7468    fn from(reference: &'a vks::core::VkAttachmentReference) -> Self {
7469        AttachmentReference {
7470            attachment: reference.attachment.into(),
7471            layout: reference.layout.into(),
7472        }
7473    }
7474}
7475
7476/// See [`VkSubpassDescription`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSubpassDescription)
7477#[derive(Debug, Clone, PartialEq, Eq, Hash)]
7478pub struct SubpassDescription {
7479    pub flags: SubpassDescriptionFlags,
7480    pub pipeline_bind_point: PipelineBindPoint,
7481    pub input_attachments: Vec<AttachmentReference>,
7482    pub color_attachments: Vec<AttachmentReference>,
7483    pub resolve_attachments: Vec<AttachmentReference>,
7484    pub depth_stencil_attachment: Option<AttachmentReference>,
7485    pub preserve_attachments: Vec<u32>,
7486}
7487
7488impl<'a> From<&'a vks::core::VkSubpassDescription> for SubpassDescription {
7489    fn from(description: &'a vks::core::VkSubpassDescription) -> Self {
7490        let input_attachments = if !description.pInputAttachments.is_null() {
7491            let input_attachments = unsafe { slice::from_raw_parts(description.pInputAttachments, description.inputAttachmentCount as usize) };
7492            input_attachments.iter().map(AttachmentReference::from).collect()
7493        }
7494        else {
7495            vec![]
7496        };
7497
7498        let color_attachments = if !description.pColorAttachments.is_null() {
7499            let color_attachments = unsafe { slice::from_raw_parts(description.pColorAttachments, description.colorAttachmentCount as usize) };
7500            color_attachments.iter().map(AttachmentReference::from).collect()
7501        }
7502        else {
7503            vec![]
7504        };
7505
7506        let resolve_attachments = if !description.pResolveAttachments.is_null() {
7507            let resolve_attachments = unsafe { slice::from_raw_parts(description.pResolveAttachments, description.colorAttachmentCount as usize) };
7508            resolve_attachments.iter().map(AttachmentReference::from).collect()
7509        }
7510        else {
7511            vec![]
7512        };
7513
7514        let depth_stencil_attachment = if !description.pDepthStencilAttachment.is_null() {
7515            unsafe { Some((&*description.pDepthStencilAttachment).into()) }
7516        }
7517        else {
7518            None
7519        };
7520
7521        let preserve_attachments = if !description.pPreserveAttachments.is_null() {
7522            unsafe { slice::from_raw_parts(description.pPreserveAttachments, description.preserveAttachmentCount as usize).to_vec() }
7523        }
7524        else {
7525            vec![]
7526        };
7527
7528        SubpassDescription {
7529            flags: SubpassDescriptionFlags::from_bits_truncate(description.flags),
7530            pipeline_bind_point: description.pipelineBindPoint.into(),
7531            input_attachments: input_attachments,
7532            color_attachments: color_attachments,
7533            resolve_attachments: resolve_attachments,
7534            depth_stencil_attachment: depth_stencil_attachment,
7535            preserve_attachments: preserve_attachments,
7536        }
7537    }
7538}
7539
7540#[derive(Debug)]
7541struct VkSubpassDescriptionWrapper {
7542    pub vks_struct: vks::core::VkSubpassDescription,
7543    input_attachments: Vec<vks::core::VkAttachmentReference>,
7544    color_attachments: Vec<vks::core::VkAttachmentReference>,
7545    resolve_attachments: Vec<vks::core::VkAttachmentReference>,
7546    depth_stencil_attachment: Option<Box<vks::core::VkAttachmentReference>>,
7547    preserve_attachments: Vec<u32>,
7548}
7549
7550impl<'a> From<&'a SubpassDescription> for VkSubpassDescriptionWrapper {
7551    fn from(description: &'a SubpassDescription) -> Self {
7552        let input_attachments: Vec<_> = description.input_attachments.iter().map(From::from).collect();
7553        let input_attachments_ptr = if !input_attachments.is_empty() {
7554            input_attachments.as_ptr()
7555        }
7556        else {
7557            ptr::null()
7558        };
7559
7560        let color_attachments: Vec<_> = description.color_attachments.iter().map(From::from).collect();
7561        let color_attachments_ptr = if !color_attachments.is_empty() {
7562            color_attachments.as_ptr()
7563        }
7564        else {
7565            ptr::null()
7566        };
7567
7568        let resolve_attachments: Vec<_> = description.resolve_attachments.iter().map(From::from).collect();
7569        let resolve_attachments_ptr = if !resolve_attachments.is_empty() {
7570            resolve_attachments.as_ptr()
7571        }
7572        else {
7573            ptr::null()
7574        };
7575
7576        let (depth_stencil_attachment_ptr, depth_stencil_attachment) = match description.depth_stencil_attachment {
7577            Some(ref depth_stencil_attachment) => {
7578                let depth_stencil_attachment = Box::new(depth_stencil_attachment.into());
7579                (&*depth_stencil_attachment as *const _, Some(depth_stencil_attachment))
7580            }
7581
7582            None => (ptr::null(), None),
7583        };
7584
7585        let preserve_attachments = description.preserve_attachments.clone();
7586        let preserve_attachments_ptr = if !preserve_attachments.is_empty() {
7587            preserve_attachments.as_ptr()
7588        }
7589        else {
7590            ptr::null()
7591        };
7592
7593        VkSubpassDescriptionWrapper {
7594            vks_struct: vks::core::VkSubpassDescription {
7595                flags: description.flags.bits(),
7596                pipelineBindPoint: description.pipeline_bind_point.into(),
7597                inputAttachmentCount: input_attachments.len() as u32,
7598                pInputAttachments: input_attachments_ptr,
7599                colorAttachmentCount: color_attachments.len() as u32,
7600                pColorAttachments: color_attachments_ptr,
7601                pResolveAttachments: resolve_attachments_ptr,
7602                pDepthStencilAttachment: depth_stencil_attachment_ptr,
7603                preserveAttachmentCount: preserve_attachments.len() as u32,
7604                pPreserveAttachments: preserve_attachments_ptr,
7605            },
7606            input_attachments: input_attachments,
7607            color_attachments: color_attachments,
7608            resolve_attachments: resolve_attachments,
7609            depth_stencil_attachment: depth_stencil_attachment,
7610            preserve_attachments: preserve_attachments,
7611        }
7612    }
7613}
7614
7615/// See [`VkSubpassDependency`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkSubpassDependency)
7616#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7617pub struct SubpassDependency {
7618    pub src_subpass: SubpassIndex,
7619    pub dst_subpass: SubpassIndex,
7620    pub src_stage_mask: PipelineStageFlags,
7621    pub dst_stage_mask: PipelineStageFlags,
7622    pub src_access_mask: AccessFlags,
7623    pub dst_access_mask: AccessFlags,
7624    pub dependency_flags: DependencyFlags,
7625}
7626
7627impl<'a> From<&'a SubpassDependency> for vks::core::VkSubpassDependency {
7628    fn from(dependency: &'a SubpassDependency) -> Self {
7629        vks::core::VkSubpassDependency {
7630            srcSubpass: dependency.src_subpass.into(),
7631            dstSubpass: dependency.dst_subpass.into(),
7632            srcStageMask: dependency.src_stage_mask.bits(),
7633            dstStageMask: dependency.dst_stage_mask.bits(),
7634            srcAccessMask: dependency.src_access_mask.bits(),
7635            dstAccessMask: dependency.dst_access_mask.bits(),
7636            dependencyFlags: dependency.dependency_flags.bits(),
7637        }
7638    }
7639}
7640
7641impl<'a> From<&'a vks::core::VkSubpassDependency> for SubpassDependency {
7642    fn from(dependency: &'a vks::core::VkSubpassDependency) -> Self {
7643        SubpassDependency {
7644            src_subpass: dependency.srcSubpass.into(),
7645            dst_subpass: dependency.dstSubpass.into(),
7646            src_stage_mask: PipelineStageFlags::from_bits_truncate(dependency.srcStageMask),
7647            dst_stage_mask: PipelineStageFlags::from_bits_truncate(dependency.dstStageMask),
7648            src_access_mask: AccessFlags::from_bits_truncate(dependency.srcAccessMask),
7649            dst_access_mask: AccessFlags::from_bits_truncate(dependency.dstAccessMask),
7650            dependency_flags: DependencyFlags::from_bits_truncate(dependency.dependencyFlags),
7651        }
7652    }
7653}
7654
7655gen_chain_struct! {
7656    name: RenderPassCreateInfoChain [RenderPassCreateInfoChainWrapper],
7657    query: RenderPassCreateInfoChainQuery [RenderPassCreateInfoChainQueryWrapper],
7658    vks: vks::core::VkRenderPassCreateInfo,
7659    input: true,
7660    output: false,
7661}
7662
7663/// See [`VkRenderPassCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkRenderPassCreateInfo)
7664#[derive(Debug, Clone, PartialEq)]
7665pub struct RenderPassCreateInfo {
7666    pub flags: RenderPassCreateFlags,
7667    pub attachments: Vec<AttachmentDescription>,
7668    pub subpasses: Vec<SubpassDescription>,
7669    pub dependencies: Vec<SubpassDependency>,
7670    pub chain: Option<RenderPassCreateInfoChain>,
7671}
7672
7673#[derive(Debug)]
7674struct VkRenderPassCreateInfoWrapper {
7675    pub vks_struct: vks::core::VkRenderPassCreateInfo,
7676    attachments: Vec<vks::core::VkAttachmentDescription>,
7677    subpasses: Vec<VkSubpassDescriptionWrapper>,
7678    vk_subpasses: Vec<vks::core::VkSubpassDescription>,
7679    dependencies: Vec<vks::core::VkSubpassDependency>,
7680    chain: Option<RenderPassCreateInfoChainWrapper>,
7681}
7682
7683impl VkRenderPassCreateInfoWrapper {
7684    pub fn new(create_info: &RenderPassCreateInfo, with_chain: bool) -> Self {
7685        let attachments: Vec<_> = create_info.attachments.iter().map(From::from).collect();
7686        let attachments_ptr = if !attachments.is_empty() {
7687            attachments.as_ptr()
7688        }
7689        else {
7690            ptr::null()
7691        };
7692
7693        let subpasses: Vec<VkSubpassDescriptionWrapper> = create_info.subpasses.iter().map(From::from).collect();
7694        let vk_subpasses: Vec<vks::core::VkSubpassDescription> = subpasses.iter().map(|s| s.vks_struct).collect();
7695
7696        let dependencies: Vec<_> = create_info.dependencies.iter().map(From::from).collect();
7697        let dependencies_ptr = if !dependencies.is_empty() {
7698            dependencies.as_ptr()
7699        }
7700        else {
7701            ptr::null()
7702        };
7703
7704        let (pnext, chain) = RenderPassCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
7705
7706        VkRenderPassCreateInfoWrapper {
7707            vks_struct: vks::core::VkRenderPassCreateInfo {
7708                sType: vks::core::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
7709                pNext: pnext,
7710                flags: create_info.flags.bits(),
7711                attachmentCount: attachments.len() as u32,
7712                pAttachments: attachments_ptr,
7713                subpassCount: subpasses.len() as u32,
7714                pSubpasses: vk_subpasses.as_ptr(),
7715                dependencyCount: dependencies.len() as u32,
7716                pDependencies: dependencies_ptr,
7717            },
7718            attachments: attachments,
7719            subpasses: subpasses,
7720            vk_subpasses: vk_subpasses,
7721            dependencies: dependencies,
7722            chain: chain,
7723        }
7724    }
7725}
7726
7727gen_chain_struct! {
7728    name: CommandPoolCreateInfoChain [CommandPoolCreateInfoChainWrapper],
7729    query: CommandPoolCreateInfoChainQuery [CommandPoolCreateInfoChainQueryWrapper],
7730    vks: vks::core::VkCommandPoolCreateInfo,
7731    input: true,
7732    output: false,
7733}
7734
7735/// See [`VkCommandPoolCreateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandPoolCreateInfo)
7736#[derive(Debug, Clone, PartialEq)]
7737pub struct CommandPoolCreateInfo {
7738    pub flags: CommandPoolCreateFlags,
7739    pub queue_family_index: u32,
7740    pub chain: Option<CommandPoolCreateInfoChain>,
7741}
7742
7743#[derive(Debug)]
7744struct VkCommandPoolCreateInfoWrapper {
7745    pub vks_struct: vks::core::VkCommandPoolCreateInfo,
7746    chain: Option<CommandPoolCreateInfoChainWrapper>,
7747}
7748
7749impl VkCommandPoolCreateInfoWrapper {
7750    pub fn new(create_info: &CommandPoolCreateInfo, with_chain: bool) -> Self {
7751        let (pnext, chain) = CommandPoolCreateInfoChainWrapper::new_optional(&create_info.chain, with_chain);
7752
7753        VkCommandPoolCreateInfoWrapper {
7754            vks_struct: vks::core::VkCommandPoolCreateInfo {
7755                sType: vks::core::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
7756                pNext: pnext,
7757                flags: create_info.flags.bits(),
7758                queueFamilyIndex: create_info.queue_family_index,
7759            },
7760            chain: chain,
7761        }
7762    }
7763}
7764
7765gen_chain_struct! {
7766    name: CommandBufferAllocateInfoChain [CommandBufferAllocateInfoChainWrapper],
7767    query: CommandBufferAllocateInfoChainQuery [CommandBufferAllocateInfoChainQueryWrapper],
7768    vks: vks::core::VkCommandBufferAllocateInfo,
7769    input: true,
7770    output: false,
7771}
7772
7773/// See [`VkCommandBufferAllocateInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandBufferAllocateInfo)
7774#[derive(Debug, Clone, PartialEq)]
7775pub struct CommandBufferAllocateInfo {
7776    pub command_pool: CommandPool,
7777    pub level: CommandBufferLevel,
7778    pub command_buffer_count: u32,
7779    pub chain: Option<CommandBufferAllocateInfoChain>,
7780}
7781
7782#[derive(Debug)]
7783struct VkCommandBufferAllocateInfoWrapper {
7784    pub vks_struct: vks::core::VkCommandBufferAllocateInfo,
7785    command_pool: CommandPool,
7786    chain: Option<CommandBufferAllocateInfoChainWrapper>,
7787}
7788
7789impl VkCommandBufferAllocateInfoWrapper {
7790    pub fn new(info: &CommandBufferAllocateInfo, with_chain: bool) -> Self {
7791        let (pnext, chain) = CommandBufferAllocateInfoChainWrapper::new_optional(&info.chain, with_chain);
7792
7793        VkCommandBufferAllocateInfoWrapper {
7794            vks_struct: vks::core::VkCommandBufferAllocateInfo {
7795                sType: vks::core::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
7796                pNext: pnext,
7797                commandPool: info.command_pool.handle(),
7798                level: info.level.into(),
7799                commandBufferCount: info.command_buffer_count,
7800            },
7801            command_pool: info.command_pool.clone(),
7802            chain: chain,
7803        }
7804    }
7805}
7806
7807gen_chain_struct! {
7808    name: CommandBufferInheritanceInfoChain [CommandBufferInheritanceInfoChainWrapper],
7809    query: CommandBufferInheritanceInfoChainQuery [CommandBufferInheritanceInfoChainQueryWrapper],
7810    vks: vks::core::VkCommandBufferInheritanceInfo,
7811    input: true,
7812    output: false,
7813}
7814
7815/// See [`VkCommandBufferInheritanceInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandBufferInheritanceInfo)
7816#[derive(Debug, Clone, PartialEq)]
7817pub struct CommandBufferInheritanceInfo {
7818    pub render_pass: Option<RenderPass>,
7819    pub subpass: u32,
7820    pub framebuffer: Option<Framebuffer>,
7821    pub occlusion_query_enable: bool,
7822    pub query_flags: QueryControlFlags,
7823    pub pipeline_statistics: QueryPipelineStatisticFlags,
7824    pub chain: Option<CommandBufferInheritanceInfoChain>,
7825}
7826
7827#[derive(Debug)]
7828struct VkCommandBufferInheritanceInfoWrapper {
7829    pub vks_struct: vks::core::VkCommandBufferInheritanceInfo,
7830    render_pass: Option<RenderPass>,
7831    framebuffer: Option<Framebuffer>,
7832    chain: Option<CommandBufferInheritanceInfoChainWrapper>,
7833}
7834
7835impl VkCommandBufferInheritanceInfoWrapper {
7836    pub fn new(info: &CommandBufferInheritanceInfo, with_chain: bool) -> Self {
7837        let (render_pass_handle, render_pass) = match info.render_pass {
7838            Some(ref render_pass) => (render_pass.handle(), Some(render_pass.clone())),
7839            None => (Default::default(), None),
7840        };
7841
7842        let (framebuffer_handle, framebuffer) = match info.framebuffer {
7843            Some(ref framebuffer) => (framebuffer.handle(), Some(framebuffer.clone())),
7844            None => (Default::default(), None),
7845        };
7846
7847        let (pnext, chain) = CommandBufferInheritanceInfoChainWrapper::new_optional(&info.chain, with_chain);
7848
7849        VkCommandBufferInheritanceInfoWrapper {
7850            vks_struct: vks::core::VkCommandBufferInheritanceInfo {
7851                sType: vks::core::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
7852                pNext: pnext,
7853                renderPass: render_pass_handle,
7854                subpass: info.subpass,
7855                framebuffer: framebuffer_handle,
7856                occlusionQueryEnable: utils::to_vk_bool(info.occlusion_query_enable),
7857                queryFlags: info.query_flags.bits(),
7858                pipelineStatistics: info.pipeline_statistics.bits(),
7859            },
7860            render_pass: render_pass,
7861            framebuffer: framebuffer,
7862            chain: chain,
7863        }
7864    }
7865}
7866
7867gen_chain_struct! {
7868    name: CommandBufferBeginInfoChain [CommandBufferBeginInfoChainWrapper],
7869    query: CommandBufferBeginInfoChainQuery [CommandBufferBeginInfoChainQueryWrapper],
7870    vks: vks::core::VkCommandBufferBeginInfo,
7871    input: true,
7872    output: false,
7873}
7874
7875/// See [`VkCommandBufferBeginInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkCommandBufferBeginInfo)
7876#[derive(Debug, Clone, PartialEq)]
7877pub struct CommandBufferBeginInfo {
7878    pub flags: CommandBufferUsageFlags,
7879    pub inheritance_info: Option<CommandBufferInheritanceInfo>,
7880    pub chain: Option<CommandBufferBeginInfoChain>,
7881}
7882
7883#[derive(Debug)]
7884struct VkCommandBufferBeginInfoWrapper {
7885    pub vks_struct: vks::core::VkCommandBufferBeginInfo,
7886    inheritance_info: Option<Box<VkCommandBufferInheritanceInfoWrapper>>,
7887    chain: Option<CommandBufferBeginInfoChainWrapper>,
7888}
7889
7890impl VkCommandBufferBeginInfoWrapper {
7891    pub fn new(begin_info: &CommandBufferBeginInfo, with_chain: bool) -> Self {
7892        let (inheritance_info_ptr, inheritance_info) = match begin_info.inheritance_info {
7893            Some(ref inheritance_info) => {
7894                let inheritance_info: Box<_> = Box::new(VkCommandBufferInheritanceInfoWrapper::new(inheritance_info, true));
7895                (&inheritance_info.vks_struct as *const _, Some(inheritance_info))
7896            }
7897
7898            None => (ptr::null(), None),
7899        };
7900
7901        let (pnext, chain) = CommandBufferBeginInfoChainWrapper::new_optional(&begin_info.chain, with_chain);
7902
7903        VkCommandBufferBeginInfoWrapper {
7904            vks_struct: vks::core::VkCommandBufferBeginInfo {
7905                sType: vks::core::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
7906                pNext: pnext,
7907                flags: begin_info.flags.bits(),
7908                pInheritanceInfo: inheritance_info_ptr,
7909            },
7910            inheritance_info: inheritance_info,
7911            chain: chain,
7912        }
7913    }
7914}
7915
7916/// See [`VkBufferCopy`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBufferCopy)
7917#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7918pub struct BufferCopy {
7919    pub src_offset: u64,
7920    pub dst_offset: u64,
7921    pub size: u64,
7922}
7923
7924impl<'a> From<&'a BufferCopy> for vks::core::VkBufferCopy {
7925    fn from(copy: &'a BufferCopy) -> Self {
7926        vks::core::VkBufferCopy {
7927            srcOffset: copy.src_offset,
7928            dstOffset: copy.dst_offset,
7929            size: copy.size,
7930        }
7931    }
7932}
7933
7934/// See [`VkImageSubresourceLayers`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageSubresourceLayers)
7935#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7936pub struct ImageSubresourceLayers {
7937    pub aspect_mask: ImageAspectFlags,
7938    pub mip_level: u32,
7939    pub base_array_layer: u32,
7940    pub layer_count: u32,
7941}
7942
7943impl<'a> From<&'a ImageSubresourceLayers> for vks::core::VkImageSubresourceLayers {
7944    fn from(layers: &'a ImageSubresourceLayers) -> Self {
7945        vks::core::VkImageSubresourceLayers {
7946            aspectMask: layers.aspect_mask.bits(),
7947            mipLevel: layers.mip_level,
7948            baseArrayLayer: layers.base_array_layer,
7949            layerCount: layers.layer_count,
7950        }
7951    }
7952}
7953
7954/// See [`VkImageCopy`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageCopy)
7955#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7956pub struct ImageCopy {
7957    pub src_subresource: ImageSubresourceLayers,
7958    pub src_offset: Offset3D,
7959    pub dst_subresource: ImageSubresourceLayers,
7960    pub dst_offset: Offset3D,
7961    pub extent: Extent3D,
7962}
7963
7964impl<'a> From<&'a ImageCopy> for vks::core::VkImageCopy {
7965    fn from(copy: &'a ImageCopy) -> Self {
7966        vks::core::VkImageCopy {
7967            srcSubresource: (&copy.src_subresource).into(),
7968            srcOffset: (&copy.src_offset).into(),
7969            dstSubresource: (&copy.dst_subresource).into(),
7970            dstOffset: (&copy.dst_offset).into(),
7971            extent: (&copy.extent).into(),
7972        }
7973    }
7974}
7975
7976/// See [`VkImageBlit`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageBlit)
7977#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7978pub struct ImageBlit {
7979    pub src_subresource: ImageSubresourceLayers,
7980    pub src_offsets: [Offset3D; 2],
7981    pub dst_subresource: ImageSubresourceLayers,
7982    pub dst_offsets: [Offset3D; 2],
7983}
7984
7985impl<'a> From<&'a ImageBlit> for vks::core::VkImageBlit {
7986    fn from(blit: &'a ImageBlit) -> Self {
7987        let src_offsets = [(&blit.src_offsets[0]).into(), (&blit.src_offsets[1]).into()];
7988        let dst_offsets = [(&blit.dst_offsets[0]).into(), (&blit.dst_offsets[1]).into()];
7989
7990        vks::core::VkImageBlit {
7991            srcSubresource: (&blit.src_subresource).into(),
7992            srcOffsets: src_offsets,
7993            dstSubresource: (&blit.dst_subresource).into(),
7994            dstOffsets: dst_offsets,
7995        }
7996    }
7997}
7998
7999/// See [`VkBufferImageCopy`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBufferImageCopy)
8000#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
8001pub struct BufferImageCopy {
8002    pub buffer_offset: u64,
8003    pub buffer_row_length: u32,
8004    pub buffer_image_height: u32,
8005    pub image_subresource: ImageSubresourceLayers,
8006    pub image_offset: Offset3D,
8007    pub image_extent: Extent3D,
8008}
8009
8010impl<'a> From<&'a BufferImageCopy> for vks::core::VkBufferImageCopy {
8011    fn from(copy: &'a BufferImageCopy) -> Self {
8012        vks::core::VkBufferImageCopy {
8013            bufferOffset: copy.buffer_offset,
8014            bufferRowLength: copy.buffer_row_length,
8015            bufferImageHeight: copy.buffer_image_height,
8016            imageSubresource: (&copy.image_subresource).into(),
8017            imageOffset: (&copy.image_offset).into(),
8018            imageExtent: (&copy.image_extent).into(),
8019        }
8020    }
8021}
8022
8023/// See [`VkClearColorValue`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkClearValue)
8024#[derive(Debug, Copy, Clone, PartialEq)]
8025pub enum ClearColorValue {
8026    Float32([f32; 4]),
8027    Int32([i32; 4]),
8028    UInt32([u32; 4]),
8029}
8030
8031impl<'a> From<&'a ClearColorValue> for vks::core::VkClearColorValue {
8032    fn from(value: &'a ClearColorValue) -> Self {
8033        match *value {
8034            ClearColorValue::Float32(value) => vks::core::VkClearColorValue { float32: value },
8035            ClearColorValue::Int32(value) => vks::core::VkClearColorValue { int32: value },
8036            ClearColorValue::UInt32(value) => vks::core::VkClearColorValue { uint32: value },
8037        }
8038    }
8039}
8040
8041/// See [`VkClearDepthStencilValue`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkClearDepthStencilValue)
8042#[derive(Debug, Copy, Clone, PartialEq)]
8043pub struct ClearDepthStencilValue {
8044    pub depth: f32,
8045    pub stencil: u32,
8046}
8047
8048impl<'a> From<&'a ClearDepthStencilValue> for vks::core::VkClearDepthStencilValue {
8049    fn from(value: &'a ClearDepthStencilValue) -> Self {
8050        vks::core::VkClearDepthStencilValue {
8051            depth: value.depth,
8052            stencil: value.stencil,
8053        }
8054    }
8055}
8056
8057/// See [`VkClearValue`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkClearValue)
8058#[derive(Debug, Copy, Clone, PartialEq)]
8059pub enum ClearValue {
8060    Color(ClearColorValue),
8061    DepthStencil(ClearDepthStencilValue),
8062}
8063
8064impl<'a> From<&'a ClearValue> for vks::core::VkClearValue {
8065    fn from(value: &'a ClearValue) -> Self {
8066        match *value {
8067            ClearValue::Color(ref value) => vks::core::VkClearValue { color: value.into() },
8068            ClearValue::DepthStencil(ref value) => vks::core::VkClearValue { depthStencil: value.into() },
8069        }
8070    }
8071}
8072
8073/// See [`VkClearAttachment`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkClearAttachment)
8074#[derive(Debug, Copy, Clone, PartialEq)]
8075pub struct ClearAttachment {
8076    pub aspect_mask: ImageAspectFlags,
8077    pub color_attachment: AttachmentIndex,
8078    pub clear_value: ClearValue,
8079}
8080
8081impl<'a> From<&'a ClearAttachment> for vks::core::VkClearAttachment {
8082    fn from(foobar: &'a ClearAttachment) -> Self {
8083        vks::core::VkClearAttachment {
8084            aspectMask: foobar.aspect_mask.bits(),
8085            colorAttachment: foobar.color_attachment.into(),
8086            clearValue: (&foobar.clear_value).into(),
8087        }
8088    }
8089}
8090
8091/// See [`VkClearRect`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkClearRect)
8092#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
8093pub struct ClearRect {
8094    pub rect: Rect2D,
8095    pub base_array_layer: u32,
8096    pub layer_count: u32,
8097}
8098
8099impl<'a> From<&'a ClearRect> for vks::core::VkClearRect {
8100    fn from(rect: &'a ClearRect) -> Self {
8101        vks::core::VkClearRect {
8102            rect: (&rect.rect).into(),
8103            baseArrayLayer: rect.base_array_layer,
8104            layerCount: rect.layer_count,
8105        }
8106    }
8107}
8108
8109/// See [`VkImageResolve`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageResolve)
8110#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
8111pub struct ImageResolve {
8112    pub src_subresource: ImageSubresourceLayers,
8113    pub src_offset: Offset3D,
8114    pub dst_subresource: ImageSubresourceLayers,
8115    pub dst_offset: Offset3D,
8116    pub extent: Extent3D,
8117}
8118
8119impl<'a> From<&'a ImageResolve> for vks::core::VkImageResolve {
8120    fn from(resolve: &'a ImageResolve) -> Self {
8121        vks::core::VkImageResolve {
8122            srcSubresource: (&resolve.src_subresource).into(),
8123            srcOffset: (&resolve.src_offset).into(),
8124            dstSubresource: (&resolve.dst_subresource).into(),
8125            dstOffset: (&resolve.dst_offset).into(),
8126            extent: (&resolve.extent).into(),
8127        }
8128    }
8129}
8130
8131gen_chain_struct! {
8132    name: MemoryBarrierChain [MemoryBarrierChainWrapper],
8133    query: MemoryBarrierChainQuery [MemoryBarrierChainQueryWrapper],
8134    vks: vks::core::VkMemoryBarrier,
8135    input: true,
8136    output: false,
8137}
8138
8139/// See [`VkMemoryBarrier`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryBarrier)
8140#[derive(Debug, Clone, PartialEq)]
8141pub struct MemoryBarrier {
8142    pub src_access_mask: AccessFlags,
8143    pub dst_access_mask: AccessFlags,
8144    pub chain: Option<MemoryBarrierChain>,
8145}
8146
8147#[derive(Debug)]
8148struct VkMemoryBarrierWrapper {
8149    pub vks_struct: vks::core::VkMemoryBarrier,
8150    chain: Option<MemoryBarrierChainWrapper>,
8151}
8152
8153impl VkMemoryBarrierWrapper {
8154    pub fn new(barrier: &MemoryBarrier, with_chain: bool) -> Self {
8155        let (pnext, chain) = MemoryBarrierChainWrapper::new_optional(&barrier.chain, with_chain);
8156
8157        VkMemoryBarrierWrapper {
8158            vks_struct: vks::core::VkMemoryBarrier {
8159                sType: vks::core::VK_STRUCTURE_TYPE_MEMORY_BARRIER,
8160                pNext: pnext,
8161                srcAccessMask: barrier.src_access_mask.bits(),
8162                dstAccessMask: barrier.dst_access_mask.bits(),
8163            },
8164            chain: chain,
8165        }
8166    }
8167}
8168
8169gen_chain_struct! {
8170    name: BufferMemoryBarrierChain [BufferMemoryBarrierChainWrapper],
8171    query: BufferMemoryBarrierChainQuery [BufferMemoryBarrierChainQueryWrapper],
8172    vks: vks::core::VkBufferMemoryBarrier,
8173    input: true,
8174    output: false,
8175}
8176
8177/// See [`VkBufferMemoryBarrier`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkBufferMemoryBarrier)
8178#[derive(Debug, Clone, PartialEq)]
8179pub struct BufferMemoryBarrier {
8180    pub src_access_mask: AccessFlags,
8181    pub dst_access_mask: AccessFlags,
8182    pub src_queue_family_index: QueueFamilyIndex,
8183    pub dst_queue_family_index: QueueFamilyIndex,
8184    pub buffer: Buffer,
8185    pub offset: u64,
8186    pub size: OptionalDeviceSize,
8187    pub chain: Option<BufferMemoryBarrierChain>,
8188}
8189
8190#[derive(Debug)]
8191struct VkBufferMemoryBarrierWrapper {
8192    pub vks_struct: vks::core::VkBufferMemoryBarrier,
8193    buffer: Buffer,
8194    chain: Option<BufferMemoryBarrierChainWrapper>,
8195}
8196
8197impl VkBufferMemoryBarrierWrapper {
8198    pub fn new(barrier: &BufferMemoryBarrier, with_chain: bool) -> Self {
8199        let (pnext, chain) = BufferMemoryBarrierChainWrapper::new_optional(&barrier.chain, with_chain);
8200
8201        VkBufferMemoryBarrierWrapper {
8202            vks_struct: vks::core::VkBufferMemoryBarrier {
8203                sType: vks::core::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
8204                pNext: pnext,
8205                srcAccessMask: barrier.src_access_mask.bits(),
8206                dstAccessMask: barrier.dst_access_mask.bits(),
8207                srcQueueFamilyIndex: barrier.src_queue_family_index.into(),
8208                dstQueueFamilyIndex: barrier.dst_queue_family_index.into(),
8209                buffer: barrier.buffer.handle(),
8210                offset: barrier.offset,
8211                size: barrier.size.into(),
8212            },
8213            buffer: barrier.buffer.clone(),
8214            chain: chain,
8215        }
8216    }
8217}
8218
8219gen_chain_struct! {
8220    name: ImageMemoryBarrierChain [ImageMemoryBarrierChainWrapper],
8221    query: ImageMemoryBarrierChainQuery [ImageMemoryBarrierChainQueryWrapper],
8222    vks: vks::core::VkImageMemoryBarrier,
8223    input: true,
8224    output: false,
8225}
8226
8227/// See [`VkImageMemoryBarrier`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkImageMemoryBarrier)
8228#[derive(Debug, Clone, PartialEq)]
8229pub struct ImageMemoryBarrier {
8230    pub src_access_mask: AccessFlags,
8231    pub dst_access_mask: AccessFlags,
8232    pub old_layout: ImageLayout,
8233    pub new_layout: ImageLayout,
8234    pub src_queue_family_index: QueueFamilyIndex,
8235    pub dst_queue_family_index: QueueFamilyIndex,
8236    pub image: Image,
8237    pub subresource_range: ImageSubresourceRange,
8238    pub chain: Option<ImageMemoryBarrierChain>,
8239}
8240
8241#[derive(Debug)]
8242struct VkImageMemoryBarrierWrapper {
8243    pub vks_struct: vks::core::VkImageMemoryBarrier,
8244    image: Image,
8245    chain: Option<ImageMemoryBarrierChainWrapper>,
8246}
8247
8248impl VkImageMemoryBarrierWrapper {
8249    pub fn new(barrier: &ImageMemoryBarrier, with_chain: bool) -> Self {
8250        let (pnext, chain) = ImageMemoryBarrierChainWrapper::new_optional(&barrier.chain, with_chain);
8251
8252        VkImageMemoryBarrierWrapper {
8253            vks_struct: vks::core::VkImageMemoryBarrier {
8254                sType: vks::core::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
8255                pNext: pnext,
8256                srcAccessMask: barrier.src_access_mask.bits(),
8257                dstAccessMask: barrier.dst_access_mask.bits(),
8258                oldLayout: barrier.old_layout.into(),
8259                newLayout: barrier.new_layout.into(),
8260                srcQueueFamilyIndex: barrier.src_queue_family_index.into(),
8261                dstQueueFamilyIndex: barrier.dst_queue_family_index.into(),
8262                image: barrier.image.handle(),
8263                subresourceRange: (&barrier.subresource_range).into(),
8264            },
8265            image: barrier.image.clone(),
8266            chain: chain,
8267        }
8268    }
8269}
8270
8271gen_chain_struct! {
8272    name: RenderPassBeginInfoChain [RenderPassBeginInfoChainWrapper],
8273    query: RenderPassBeginInfoChainQuery [RenderPassBeginInfoChainQueryWrapper],
8274    vks: vks::core::VkRenderPassBeginInfo,
8275    input: true,
8276    output: false,
8277}
8278
8279/// See [`VkRenderPassBeginInfo`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkRenderPassBeginInfo)
8280#[derive(Debug, Clone, PartialEq)]
8281pub struct RenderPassBeginInfo {
8282    pub render_pass: RenderPass,
8283    pub framebuffer: Framebuffer,
8284    pub render_area: Rect2D,
8285    pub clear_values: Vec<ClearValue>,
8286    pub chain: Option<RenderPassBeginInfoChain>,
8287}
8288
8289#[derive(Debug)]
8290struct VkRenderPassBeginInfoWrapper {
8291    pub vks_struct: vks::core::VkRenderPassBeginInfo,
8292    render_pass: RenderPass,
8293    framebuffer: Framebuffer,
8294    clear_values: Vec<vks::core::VkClearValue>,
8295    chain: Option<RenderPassBeginInfoChainWrapper>,
8296}
8297
8298impl VkRenderPassBeginInfoWrapper {
8299    pub fn new(begin_info: &RenderPassBeginInfo, with_chain: bool) -> Self {
8300        let clear_values: Vec<_> = begin_info.clear_values.iter().map(From::from).collect();
8301        let clear_values_ptr = if !clear_values.is_empty() {
8302            clear_values.as_ptr()
8303        }
8304        else {
8305            ptr::null()
8306        };
8307
8308        let (pnext, chain) = RenderPassBeginInfoChainWrapper::new_optional(&begin_info.chain, with_chain);
8309
8310        VkRenderPassBeginInfoWrapper {
8311            vks_struct: vks::core::VkRenderPassBeginInfo {
8312                sType: vks::core::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
8313                pNext: pnext,
8314                renderPass: begin_info.render_pass.handle(),
8315                framebuffer: begin_info.framebuffer.handle(),
8316                renderArea: (&begin_info.render_area).into(),
8317                clearValueCount: clear_values.len() as u32,
8318                pClearValues: clear_values_ptr,
8319            },
8320            render_pass: begin_info.render_pass.clone(),
8321            framebuffer: begin_info.framebuffer.clone(),
8322            clear_values: clear_values,
8323            chain: chain,
8324        }
8325    }
8326}
8327
8328/// See [`VkDispatchIndirectCommand`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDispatchIndirectCommand)
8329#[repr(C)]
8330#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
8331pub struct DispatchIndirectCommand {
8332    pub x: u32,
8333    pub y: u32,
8334    pub z: u32,
8335}
8336
8337/// See [`VkDrawIndexedIndirectCommand`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDrawIndexedIndirectCommand)
8338#[repr(C)]
8339#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
8340pub struct DrawIndexedIndirectCommand {
8341    pub index_count: u32,
8342    pub instance_count: u32,
8343    pub first_index: u32,
8344    pub vertex_offset: i32,
8345    pub first_instance: u32,
8346}
8347
8348/// See [`VkDrawIndirectCommand`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkDrawIndirectCommand)
8349#[repr(C)]
8350#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
8351pub struct DrawIndirectCommand {
8352    pub vertex_count: u32,
8353    pub instance_count: u32,
8354    pub first_vertex: u32,
8355    pub first_instance: u32,
8356}
dacite/core/mod.rs

dacite/core/
mod.rs
